create-cmp-cli 0.8.0 → 0.10.0

package/template/qa/verify.mjs

@@ -26,6 +26,9 @@ import { fileURLToPath } from "node:url";
 
 import { computeInputsHash } from "./lib/inputs-hash.mjs";
 import { compareTokenDrift } from "./lib/token-drift.mjs";
+import { evaluateApprovalsGate } from "./lib/approvals.mjs";
+import { evaluateComponentStoryParity } from "./lib/component-stories.mjs";
+import { ARCH_DOC_REL_PATH, SECTION_IDS, regenerateArchDoc } from "./lib/arch-doc.mjs";
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const EVIDENCE_DIR = path.join(ROOT, "qa", "evidence");
@@ -46,6 +49,30 @@ function sh(cmd, opts = {}) {
   return { ok, status: res.status, error: res.error?.message, out: `${res.stdout ?? ""}${res.stderr ?? ""}`, durationMs: Date.now() - started };
 }
 
+// ── Preview-daemon coexistence ──────────────────────────────────────────────
+// The preview daemon (the eyes) and this lane both spawn Gradle against this
+// project and share composeApp/build/kspCaches, whose KSP incremental storage
+// is single-owner — two concurrent builds throw "Storage for [...] is already
+// registered" and one side dies. Two defenses, both automatic:
+//   1. COORDINATE: this lane stamps a marker file for its duration; the preview
+//      service defers renders while it exists (mtime-bounded, so a crashed lane
+//      never wedges the eyes for long).
+//   2. SELF-HEAL: a Gradle step that still hits the collision clears kspCaches
+//      and retries once — the manual recovery that always worked, automated.
+const LANE_MARKER = path.join(ROOT, "composeApp", "build", ".cmp-lane-in-progress");
+const KSP_COLLISION_RE = /Storage for \[[^\]]*\] is already registered/;
+
+function shGradle(cmd, opts = {}) {
+  const first = sh(cmd, opts);
+  if (first.ok || !KSP_COLLISION_RE.test(first.out)) return first;
+  console.error("· KSP cache collision (concurrent Gradle — the preview daemon?) — clearing kspCaches, retrying once");
+  fs.rmSync(path.join(ROOT, "composeApp", "build", "kspCaches"), { recursive: true, force: true });
+  const retry = sh(cmd, opts);
+  retry.durationMs += first.durationMs;
+  retry.selfHealed = "ksp-cache-collision";
+  return retry;
+}
+
 function tryGit(cmd) {
   try {
     return execSync(`git ${cmd}`, { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
@@ -54,6 +81,22 @@ function tryGit(cmd) {
   }
 }
 
+/**
+ * Line-oriented git output, WITHOUT [tryGit]'s trim. `git status --porcelain`
+ * has significant leading whitespace: an unstaged modification is `" M path"`,
+ * so trimming the whole blob eats the first line's leading space — and a fixed
+ * `slice(3)` then swallows that path's first character. The receipt would name
+ * a file that does not exist. Only trailing newlines are dropped here.
+ */
+function tryGitLines(cmd) {
+  try {
+    const out = execSync(`git ${cmd}`, { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return out.replace(/\n+$/, "").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 function junitSummary(dir) {
   if (!fs.existsSync(dir)) return null;
   let tests = 0, failures = 0, errors = 0, skipped = 0;
@@ -176,8 +219,79 @@ function stepSpecCoverage() {
   };
 }
 
+// Human-approval gate (VERIFICATION-LAYER-DESIGN.md §2) — pure Node, no Gradle,
+// same grouping as specCoverage. The decision itself lives in
+// qa/lib/approvals.mjs (evaluateApprovalsGate); this step only adds the
+// name/duration bookkeeping every step in this file carries.
+function stepApprovals() {
+  const started = Date.now();
+  const { verdict, reason, statuses } = evaluateApprovalsGate(ROOT);
+  return {
+    name: "approvals",
+    verdict,
+    reason,
+    durationMs: Date.now() - started,
+    details: { artifacts: statuses.map((s) => ({ id: s.id, status: s.status, hash: s.hash })) },
+  };
+}
+
+// Component ↔ story parity gate (STUDIO-REDESIGN.md §3.3) — pure Node, no
+// Gradle, same grouping as specCoverage/approvals. The decision itself lives
+// in qa/lib/component-stories.mjs (evaluateComponentStoryParity); this step
+// only adds the name/duration bookkeeping every step in this file carries.
+function stepComponentStories() {
+  const started = Date.now();
+  const { verdict, reason, details } = evaluateComponentStoryParity(ROOT);
+  return { name: "componentStories", verdict, reason, durationMs: Date.now() - started, details };
+}
+
+// Architecture-doc freshness gate (Wave B, docs/proposals/architecture-document-
+// standard.md §6) — pure Node, no Gradle, same grouping as specCoverage/
+// approvals. The decision itself lives in qa/lib/arch-doc.mjs
+// (regenerateArchDoc); this step only adds the name/duration bookkeeping every
+// step in this file carries, plus wording the FAIL reason for an AI
+// collaborator (name the stale/missing section, name the fix command).
+function stepArchDoc() {
+  const started = Date.now();
+  const elapsed = () => Date.now() - started;
+
+  const result = regenerateArchDoc(ROOT);
+  if (!result.ok) {
+    return { name: "archDoc", verdict: "SKIP", reason: `${result.reason} — nothing to check`, durationMs: elapsed() };
+  }
+  if (result.unknownSections.length > 0) {
+    return {
+      name: "archDoc",
+      verdict: "FAIL",
+      reason: `${ARCH_DOC_REL_PATH} has cmp:generated marker(s) with no registered generator: ${result.unknownSections.join(", ")} — add a generator in qa/lib/arch-doc.mjs or remove the marker.`,
+      durationMs: elapsed(),
+    };
+  }
+
+  const stale = result.changed || result.missingSections.length > 0;
+  if (!stale) {
+    return { name: "archDoc", verdict: "PASS", durationMs: elapsed(), details: { sectionsChecked: SECTION_IDS.length } };
+  }
+
+  const lines = [`${ARCH_DOC_REL_PATH} is stale — a generated section no longer matches the tree:`];
+  for (const id of result.changedSections) {
+    lines.push(`  [${id}] regenerating would change this section.`);
+  }
+  for (const id of result.missingSections) {
+    lines.push(`  [${id}] marker missing from the doc entirely — never generated.`);
+  }
+  lines.push("Run: node qa/arch-doc.mjs");
+  return {
+    name: "archDoc",
+    verdict: "FAIL",
+    reason: lines.join("\n"),
+    durationMs: elapsed(),
+    details: { changedSections: result.changedSections, missingSections: result.missingSections },
+  };
+}
+
 function stepBuild() {
-  const res = sh(`${GRADLEW} :composeApp:assembleDebug --console=plain`);
+  const res = shGradle(`${GRADLEW} :composeApp:assembleDebug --console=plain`);
   return {
     name: "build",
     verdict: res.ok ? "PASS" : "FAIL",
@@ -191,7 +305,7 @@ function stepBuild() {
 // cached) while `--rerun` forces the tests themselves to EXECUTE — see stepUnitTests.
 function gradleTestStep(name, testsFilter, failHint) {
   return () => {
-    const res = sh(`${GRADLEW} :composeApp:desktopTest --rerun --tests "${testsFilter}" --console=plain`);
+    const res = shGradle(`${GRADLEW} :composeApp:desktopTest --rerun --tests "${testsFilter}" --console=plain`);
     return {
       name,
       verdict: res.ok ? "PASS" : "FAIL",
@@ -209,7 +323,7 @@ function stepUnitTests() {
   // produce byte-identical sources, and golden baselines aren't compile inputs), so the
   // receipt would attest tests that never executed. Compilation stays cached — only the
   // test execution is forced.
-  const res = sh(`${GRADLEW} :composeApp:desktopTest --rerun --console=plain`);
+  const res = shGradle(`${GRADLEW} :composeApp:desktopTest --rerun --console=plain`);
   const summary = junitSummary(path.join(ROOT, "composeApp/build/test-results/desktopTest"));
   return {
     name: "unitTests",
@@ -362,7 +476,7 @@ function stepE2eSmoke() {
   if (!maestroAvailable()) {
     return { name: "e2eSmoke", verdict: "SKIP", reason: "maestro CLI not installed — curl -fsSL https://get.maestro.mobile.dev | bash", durationMs: 0 };
   }
-  const install = sh(`${GRADLEW} :composeApp:installDebug --console=plain`);
+  const install = shGradle(`${GRADLEW} :composeApp:installDebug --console=plain`);
   if (!install.ok) {
     return { name: "e2eSmoke", verdict: "FAIL", reason: "installDebug failed — the APK could not be installed on the attached device", durationMs: install.durationMs };
   }
@@ -372,15 +486,44 @@ function stepE2eSmoke() {
   //    that steal focus over the app — a Maestro assert would then see only the dialog;
   //  - MAESTRO_DRIVER_STARTUP_TIMEOUT gives the UiAutomator2 driver a generous budget to come
   //    up on a slow emulator (the built-in default gives up too early under load).
-  // Both are benign, reversible, and only touch the device while the lane is driving it.
+  // Both are benign, reversible, and only touch the device while the lane is driving it —
+  // hide_error_dialogs is restored to its pre-run value (or deleted, returning the device
+  // to its default) in the finally below, on every exit path.
+  // hide_error_dialogs suppresses the OS dialog, NEVER the underlying event — so after the
+  // run we grep the device log for ANR/crash lines the dialog would have shown, and FAIL on
+  // them. The eyes must report what automation stability had to hide.
+  const prevHideErrorDialogs = sh("adb shell settings get global hide_error_dialogs").out.trim();
   sh("adb shell settings put global hide_error_dialogs 1");
-  const res = sh("maestro test qa/e2e/smoke.yaml", { env: { ...process.env, MAESTRO_DRIVER_STARTUP_TIMEOUT: "120000" } });
-  return {
-    name: "e2eSmoke",
-    verdict: res.ok ? "PASS" : "FAIL",
-    reason: res.ok ? undefined : `Maestro smoke failed (flow cites the SHELL spec clauses it proves):\n${res.out.split("\n").slice(-15).join("\n")}`,
-    durationMs: install.durationMs + res.durationMs,
-  };
+  sh("adb logcat -c"); // clear so the post-run dump only reflects this run
+  try {
+    const res = sh("maestro test qa/e2e/smoke.yaml", { env: { ...process.env, MAESTRO_DRIVER_STARTUP_TIMEOUT: "120000" } });
+    if (!res.ok) {
+      return {
+        name: "e2eSmoke",
+        verdict: "FAIL",
+        reason: `Maestro smoke failed (flow cites the SHELL spec clauses it proves):\n${res.out.split("\n").slice(-15).join("\n")}`,
+        durationMs: install.durationMs + res.durationMs,
+      };
+    }
+    const anrDump = sh("adb logcat -d -b system,crash,main");
+    const anrRe = /ANR in |FATAL EXCEPTION/i;
+    if (anrDump.ok && anrRe.test(anrDump.out)) {
+      const anrLines = anrDump.out.split("\n").filter((l) => anrRe.test(l)).slice(0, 10).join("\n");
+      return {
+        name: "e2eSmoke",
+        verdict: "FAIL",
+        reason: `Maestro smoke passed, but the device log shows an ANR/crash during the run (hide_error_dialogs only suppresses the OS dialog, never the underlying event):\n${anrLines}`,
+        durationMs: install.durationMs + res.durationMs,
+      };
+    }
+    return { name: "e2eSmoke", verdict: "PASS", durationMs: install.durationMs + res.durationMs };
+  } finally {
+    if (prevHideErrorDialogs && prevHideErrorDialogs !== "null") {
+      sh(`adb shell settings put global hide_error_dialogs ${prevHideErrorDialogs}`);
+    } else {
+      sh("adb shell settings delete global hide_error_dialogs");
+    }
+  }
 }
 
 // ── Lane ───────────────────────────────────────────────────────────────────
@@ -388,9 +531,12 @@ function stepE2eSmoke() {
 const stepsForProfile = {
   // scaffold: what `create-cmp --verify` proves at stamp time — specCoverage,
   // the full JVM tier (unit + conformance + golden + UI tests) plus the Android build.
-  scaffold: [stepSpecCoverage, stepBuild, stepUnitTests],
+  scaffold: [stepSpecCoverage, stepApprovals, stepComponentStories, stepArchDoc, stepBuild, stepUnitTests],
   local: [
     stepSpecCoverage,
+    stepApprovals,
+    stepComponentStories,
+    stepArchDoc,
     stepBuild,
     stepUnitTests,
     stepConformance,
@@ -407,7 +553,12 @@ if (!stepsForProfile[profile]) {
   process.exit(2);
 }
 
+// Stamp the lane marker for the run's duration (coexistence defense 1 above);
+// always removed, even on a failing step, so the eyes only ever defer briefly.
+fs.mkdirSync(path.dirname(LANE_MARKER), { recursive: true });
+fs.writeFileSync(LANE_MARKER, `${process.pid} ${new Date().toISOString()}\n`);
 const steps = [];
+try {
 for (const step of stepsForProfile[profile]) {
   const result = step();
   steps.push(result);
@@ -417,9 +568,20 @@ for (const step of stepsForProfile[profile]) {
   }
   if (result.name === "build" && result.verdict === "FAIL") break; // nothing downstream is meaningful
 }
+} finally {
+  fs.rmSync(LANE_MARKER, { force: true });
+}
 
 const verdict = steps.some((s) => s.verdict === "FAIL") ? "FAIL" : "PASS";
 
+// Receipt STRENGTH — a desktop-only green and an on-device green are different
+// claims, and the difference should never live only in the SKIP lines. Device-
+// dependent steps that actually RAN (PASSed) are named on the receipt and in the
+// verdict line: "PASS (on-device: e2eSmoke)" vs "PASS (desktop-only)".
+const DEVICE_STEPS = ["e2eSmoke", "tokenDrift"];
+const onDeviceSteps = steps.filter((s) => DEVICE_STEPS.includes(s.name) && s.verdict === "PASS").map((s) => s.name);
+const strengthLabel = onDeviceSteps.length ? `on-device: ${onDeviceSteps.join("+")}` : "desktop-only";
+
 // Artifacts: hash whatever the run left under qa-artifacts/ (never committed).
 const artifacts = [];
 if (fs.existsSync(ARTIFACTS_DIR)) {
@@ -448,13 +610,14 @@ const receipt = {
   verdict,
   commit: {
     sha: tryGit("rev-parse HEAD"),
-    dirty: (tryGit("status --porcelain") ?? "").split("\n").filter(Boolean).map((l) => l.slice(3)).sort(),
+    dirty: tryGitLines("status --porcelain").map((l) => l.slice(3)).sort(),
   },
   inputs: {
     hash: inputs.hash,
     fileCount: inputs.fileCount,
   },
   steps,
+  strength: { onDeviceSteps },
   artifacts,
   toolVersions: {
     node: process.version,
@@ -465,8 +628,11 @@ const receipt = {
 
 fs.mkdirSync(EVIDENCE_DIR, { recursive: true });
 fs.writeFileSync(path.join(EVIDENCE_DIR, "latest.json"), `${JSON.stringify(receipt, null, 2)}\n`);
+// latest.json is the single receipt-of-record. Commit it with your change: the
+// studio console's Evidence audit trail reconstructs the full history from the
+// git log of this file — every commit is one verified, attributed state.
 
 if (asJson) console.log(JSON.stringify(receipt, null, 2));
-else console.log(`\n${verdict === "PASS" ? "✅" : "❌"} verify lane: ${verdict} — receipt written to qa/evidence/latest.json (commit it with your change)`);
+else console.log(`\n${verdict === "PASS" ? "✅" : "❌"} verify lane: ${verdict} (${strengthLabel}) — receipt written to qa/evidence/latest.json (commit it with your change)`);
 
 process.exit(verdict === "PASS" ? 0 : 1);