ci: speed up release metadata pre-commit checks

scripts/changed-lanes.mjs

@@ -14,8 +14,21 @@ const TEST_PATH_RE =
   /(?:^|\/)(?:test|__tests__)\/|(?:\.|\/)(?:test|spec|e2e|browser\.test)\.[cm]?[jt]sx?$/u;
 const PUBLIC_EXTENSION_CONTRACT_RE =
   /^(?:src\/plugin-sdk\/|src\/plugins\/contracts\/|src\/channels\/plugins\/|scripts\/lib\/plugin-sdk-entrypoints\.json$|scripts\/sync-plugin-sdk-exports\.mjs$|scripts\/generate-plugin-sdk-api-baseline\.ts$)/u;
+export const RELEASE_METADATA_PATHS = new Set([
+  "CHANGELOG.md",
+  "apps/android/app/build.gradle.kts",
+  "apps/ios/CHANGELOG.md",
+  "apps/ios/Config/Version.xcconfig",
+  "apps/ios/fastlane/metadata/en-US/release_notes.txt",
+  "apps/ios/version.json",
+  "apps/macos/Sources/OpenClaw/Resources/Info.plist",
+  "docs/.generated/config-baseline.sha256",
+  "docs/install/updating.md",
+  "package.json",
+  "src/config/schema.base.generated.ts",
+]);
 
-/** @typedef {"core" | "coreTests" | "extensions" | "extensionTests" | "apps" | "docs" | "tooling" | "all"} ChangedLane */
+/** @typedef {"core" | "coreTests" | "extensions" | "extensionTests" | "apps" | "docs" | "tooling" | "releaseMetadata" | "all"} ChangedLane */
 
 /**
  * @typedef {{
@@ -43,6 +56,7 @@ export function createEmptyChangedLanes() {
     apps: false,
     docs: false,
     tooling: false,
+    releaseMetadata: false,
     all: false,
   };
 }
@@ -65,6 +79,20 @@ export function detectChangedLanes(changedPaths) {
     return { paths, lanes, extensionImpactFromCore: false, docsOnly: false, reasons };
   }
 
+  if (
+    paths.some((changedPath) => RELEASE_METADATA_PATHS.has(changedPath)) &&
+    paths.every(
+      (changedPath) => RELEASE_METADATA_PATHS.has(changedPath) || DOCS_PATH_RE.test(changedPath),
+    )
+  ) {
+    lanes.releaseMetadata = true;
+    lanes.docs = paths.some((changedPath) => DOCS_PATH_RE.test(changedPath));
+    for (const changedPath of paths) {
+      reasons.push(`${changedPath}: release metadata`);
+    }
+    return { paths, lanes, extensionImpactFromCore: false, docsOnly: false, reasons };
+  }
+
   for (const changedPath of paths) {
     if (DOCS_PATH_RE.test(changedPath)) {
       lanes.docs = true;

scripts/check-changed.mjs

@@ -10,7 +10,7 @@ import { booleanFlag, parseFlagArgs, stringFlag } from "./lib/arg-utils.mjs";
 import { printTimingSummary } from "./lib/check-timing-summary.mjs";
 import { resolveChangedTestTargetPlan } from "./test-projects.test-support.mjs";
 
-export function createChangedCheckPlan(result) {
+export function createChangedCheckPlan(result, options = {}) {
   const commands = [];
   const add = (name, args) => {
     if (!commands.some((command) => command.name === name && sameArgs(command.args, args))) {
@@ -34,6 +34,28 @@ export function createChangedCheckPlan(result) {
   const lanes = result.lanes;
   const runAll = lanes.all;
 
+  if (lanes.releaseMetadata) {
+    add("release metadata guard", [
+      "release-metadata:check",
+      "--",
+      ...(options.staged
+        ? ["--staged"]
+        : ["--base", options.base ?? "origin/main", "--head", options.head ?? "HEAD"]),
+    ]);
+    add("iOS version sync", ["ios:version:check"]);
+    add("config schema baseline", ["config:schema:check"]);
+    add("config docs baseline", ["config:docs:check"]);
+    add("root dependency ownership", ["deps:root-ownership:check"]);
+    return {
+      commands,
+      testTargets: [],
+      runChangedTestsBroad: false,
+      runFullTests: false,
+      runExtensionTests: false,
+      summary: "release metadata",
+    };
+  }
+
   if (runAll) {
     add("typecheck all", ["tsgo:all"]);
     add("lint", ["lint"]);
@@ -99,7 +121,7 @@ export function createChangedCheckPlan(result) {
 }
 
 export async function runChangedCheck(result, options = {}) {
-  const plan = createChangedCheckPlan(result);
+  const plan = createChangedCheckPlan(result, options);
   printPlan(result, plan, options);
 
   if (options.dryRun) {

scripts/check-release-metadata-only.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { RELEASE_METADATA_PATHS } from "./changed-lanes.mjs";
+
+const VERSION_ONLY_TEXT_PATHS = new Set([
+  "apps/android/app/build.gradle.kts",
+  "apps/ios/Config/Version.xcconfig",
+  "apps/ios/version.json",
+  "apps/macos/Sources/OpenClaw/Resources/Info.plist",
+  "src/config/schema.base.generated.ts",
+]);
+
+function normalizePath(input) {
+  return String(input ?? "")
+    .trim()
+    .replaceAll("\\", "/")
+    .replace(/^\.\/+/u, "");
+}
+
+function parseArgs(argv) {
+  const args = { staged: false, base: "origin/main", head: "HEAD", paths: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--staged") {
+      args.staged = true;
+    } else if (arg === "--base") {
+      args.base = argv[++index] ?? "";
+    } else if (arg === "--head") {
+      args.head = argv[++index] ?? "";
+    } else {
+      args.paths.push(normalizePath(arg));
+    }
+  }
+  return args;
+}
+
+function git(args) {
+  return execFileSync("git", args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+  });
+}
+
+function listChangedPaths(args) {
+  if (args.paths.length > 0) {
+    return [...new Set(args.paths.filter(Boolean))].toSorted((left, right) =>
+      left.localeCompare(right),
+    );
+  }
+  const diffArgs = args.staged
+    ? ["diff", "--cached", "--name-only", "--diff-filter=ACMR"]
+    : ["diff", "--name-only", "--diff-filter=ACMR", `${args.base}...${args.head}`];
+  return git(diffArgs)
+    .split("\n")
+    .map(normalizePath)
+    .filter(Boolean)
+    .toSorted((left, right) => left.localeCompare(right));
+}
+
+function readBlob(ref, filePath) {
+  if (ref === "WORKTREE") {
+    return readFileSync(filePath, "utf8");
+  }
+  return git(["show", `${ref}:${filePath}`]);
+}
+
+function refsFor(args) {
+  return args.staged ? { before: "HEAD", after: "" } : { before: args.base, after: args.head };
+}
+
+function readBeforeAfter(args, filePath) {
+  const refs = refsFor(args);
+  const before = readBlob(refs.before, filePath);
+  let after = readBlob(refs.after, filePath);
+  if (!args.staged && existsSync(filePath)) {
+    const worktree = readBlob("WORKTREE", filePath);
+    if (worktree !== after) {
+      after = worktree;
+    }
+  }
+  return {
+    before,
+    after,
+  };
+}
+
+function stripPackageVersion(raw) {
+  const parsed = JSON.parse(raw);
+  delete parsed.version;
+  return stableJson(parsed);
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .toSorted((left, right) => left.localeCompare(right))
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function normalizeVersionText(raw) {
+  return raw
+    .replace(/\b20\d{2}\.\d{1,2}\.\d{1,2}(?:-beta\.\d+|-\d+)?\b/gu, "<OPENCLAW_VERSION>")
+    .replace(/\b20\d{6}(?:\d{2})?\b/gu, "<OPENCLAW_BUILD>");
+}
+
+function fail(message) {
+  console.error(`[release-metadata] ${message}`);
+  process.exitCode = 1;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const paths = listChangedPaths(args);
+
+  for (const filePath of paths) {
+    if (!RELEASE_METADATA_PATHS.has(filePath)) {
+      fail(`${filePath}: not a release metadata path; run the normal changed gate`);
+    }
+  }
+
+  if (paths.includes("package.json")) {
+    const { before, after } = readBeforeAfter(args, "package.json");
+    if (stripPackageVersion(before) !== stripPackageVersion(after)) {
+      fail("package.json changed outside the top-level version field");
+    }
+  }
+
+  for (const filePath of paths) {
+    if (!VERSION_ONLY_TEXT_PATHS.has(filePath)) {
+      continue;
+    }
+    const { before, after } = readBeforeAfter(args, filePath);
+    if (normalizeVersionText(before) !== normalizeVersionText(after)) {
+      fail(`${filePath}: changed outside recognized version/build literals`);
+    }
+  }
+
+  if (process.exitCode) {
+    process.exit(process.exitCode);
+  }
+  console.error(`[release-metadata] ok (${paths.length} files)`);
+}
+
+main();