@decohere/ci-tools 0.0.1-dev.12 → 0.0.1-dev.120

package/src/github/smoke-create-launcher.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+/**
+ * Run `npx @decohere/create@version --help` from an empty temp directory.
+ * Must not use the repo cwd — after `@decohere/cli` is pinned, pnpm installs
+ * `@decohere/create` into the workspace tree and npm's npx misses the bin.
+ *
+ * @param {{
+ *   createVersion: string,
+ *   authToken: string,
+ *   mkdtempSync?: typeof mkdtempSync,
+ *   writeFileSync?: typeof writeFileSync,
+ *   spawnSync?: typeof spawnSync,
+ *   tmpdir?: () => string,
+ *   stdio?: import("node:child_process").StdioOptions,
+ * }} options
+ */
+export function runCreateLauncherSmoke(options) {
+	const version = options.createVersion?.trim() ?? "";
+	const token = options.authToken?.trim() ?? "";
+	if (!version) {
+		throw new Error("CREATE_VERSION is required");
+	}
+	if (!token) {
+		throw new Error("NODE_AUTH_TOKEN is required");
+	}
+
+	const mkdtemp = options.mkdtempSync ?? mkdtempSync;
+	const writeFile = options.writeFileSync ?? writeFileSync;
+	const spawn = options.spawnSync ?? spawnSync;
+	const tmp = options.tmpdir ?? tmpdir;
+
+	const workDir = mkdtemp(join(tmp(), "decohere-create-smoke-"));
+	const npmrc = join(workDir, ".npmrc");
+	writeFile(
+		npmrc,
+		`@decohere:registry=https://registry.npmjs.org/\n//registry.npmjs.org/:_authToken=${token}\n`,
+	);
+
+	const result = spawn("npx", ["--yes", `@decohere/create@${version}`, "--help"], {
+		cwd: workDir,
+		env: {
+			...process.env,
+			NPM_CONFIG_USERCONFIG: npmrc,
+			NODE_AUTH_TOKEN: token,
+		},
+		stdio: options.stdio ?? "inherit",
+	});
+
+	return {
+		workDir,
+		status: result.status ?? 1,
+	};
+}
+
+const isCli =
+	process.argv[1] != null && import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+
+if (isCli) {
+	const { status } = runCreateLauncherSmoke({
+		createVersion: process.env.CREATE_VERSION ?? "",
+		authToken: process.env.NODE_AUTH_TOKEN ?? "",
+	});
+	process.exit(status);
+}

package/src/lib/github-issue.mjs

@@ -0,0 +1,75 @@
+/**
+ * One GitHub issue per subject, found again by its exact title and updated in place: CI files
+ * a reminder once and keeps it current instead of opening a new issue every run. Needs `gh` and
+ * GH_TOKEN (or GITHUB_TOKEN) with issues: write.
+ */
+
+import { spawnSync } from "node:child_process";
+
+/**
+ * @param {string[]} args
+ * @param {string} [input]
+ */
+export function gh(args, input) {
+	const result = spawnSync("gh", args, { encoding: "utf8", input, env: process.env });
+	if (result.status !== 0) {
+		throw new Error(result.stderr || result.stdout || `gh ${args.join(" ")} failed`);
+	}
+	return result.stdout;
+}
+
+/**
+ * The issue titled exactly `title`, preferring an open one over a closed one.
+ *
+ * @param {{ number: number, title: string, state: string, url: string }[]} issues
+ * @param {string} title
+ */
+export function pickIssue(issues, title) {
+	const matches = issues.filter((issue) => issue.title === title);
+	return matches.find((issue) => issue.state === "OPEN") ?? matches[0] ?? null;
+}
+
+/**
+ * @param {{ title: string, body: string, assignees?: string[], repo?: string }} options
+ * @param {typeof gh} [run]
+ * @returns {{ number: number, url: string, created: boolean }}
+ */
+export function upsertIssue(options, run = gh) {
+	const { title, body, assignees = [] } = options;
+	const repo = options.repo ? ["--repo", options.repo] : [];
+	const issues = JSON.parse(
+		run([
+			"issue",
+			"list",
+			...repo,
+			"--state",
+			"all",
+			"--limit",
+			"200",
+			"--search",
+			// Quoted: GitHub's search can't match a title like `security(ci): …` unquoted (#681).
+			// The exact-title match in pickIssue still decides.
+			`"${title.replaceAll('"', "")}" in:title`,
+			"--json",
+			"number,title,state,url",
+		]),
+	);
+	const assign = assignees.flatMap((login) => ["--add-assignee", login]);
+	const existing = pickIssue(issues, title);
+	if (existing != null) {
+		if (existing.state !== "OPEN") {
+			run(["issue", "reopen", String(existing.number), ...repo]);
+		}
+		run(
+			["issue", "edit", String(existing.number), ...repo, "--body-file", "-", ...assign],
+			body,
+		);
+		return { number: existing.number, url: existing.url, created: false };
+	}
+	const url = run(
+		["issue", "create", ...repo, "--title", title, "--body-file", "-", ...assign],
+		body,
+	).trim();
+	const number = Number(url.split("/").pop());
+	return { number, url, created: true };
+}

package/src/lib/workspace-packages.mjs

@@ -0,0 +1,30 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+// The same rule as WorkspaceDefaults in @decohere/workspace (`projects/**/package.json`, minus these
+// folders, and a package.json inside another project is not a project). CI scripts run on plain
+// Node before any install, so they can't import the workspace package itself.
+const SKIP = new Set(["node_modules", "__fixtures__", "dist"]);
+
+/**
+ * Every project directory under `<root>/projects`, at any depth (`projects/cli`,
+ * `projects/data/data-typeorm`).
+ * @param {string} root
+ * @returns {string[]} absolute paths
+ */
+export function listProjectDirs(root) {
+	const found = [];
+	const walk = (dir) => {
+		if (existsSync(join(dir, "package.json"))) {
+			found.push(dir);
+			return;
+		}
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isDirectory() && !SKIP.has(entry.name) && !entry.name.startsWith(".")) {
+				walk(join(dir, entry.name));
+			}
+		}
+	};
+	walk(join(root, "projects"));
+	return found;
+}

package/src/pages/artifact.mjs

@@ -1,5 +1,8 @@
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { normalize } from "../bench/history.mjs";
+import { buildBenchmarkHtml, buildStylesCss } from "./bench-page.mjs";
 
 const branch = process.env.GITHUB_REF_NAME ?? "local";
 const sha = process.env.GITHUB_SHA ?? "local";
@@ -8,201 +11,53 @@ const outputDir = process.env.PAGES_OUTPUT_DIR ?? "site";
 const badgesDir = "projects/ci-tools/dist/ci/badges";
 const benchHistoryPath = "projects/ci-tools/dist/ci/bench/bench-history.json";
 
-const numericFields = ["hz", "mean", "p99", "rme", "sampleCount"];
-
-function fmtMs(ms) {
-	if (typeof ms !== "number" || Number.isNaN(ms)) return "-";
-	if (ms >= 100) return `${Math.round(ms)} ms`;
-	return `${ms.toFixed(1)} ms`;
-}
-
-function fmtHz(hz) {
-	if (typeof hz !== "number" || Number.isNaN(hz)) return "-";
-	return `${hz.toFixed(2)}/s`;
-}
-
-function averageBenchmarks(runs) {
-	const first = runs[0]?.vitestOutput;
-	if (first == null) return [];
-
-	const latestBenchmarks = first.files
-		.flatMap((file) => file.groups)
-		.flatMap((group) => group.benchmarks);
-
-	return latestBenchmarks.map((benchmark) => {
-		const peers = runs
-			.flatMap((run) => run.vitestOutput?.files ?? [])
-			.flatMap((file) => file.groups ?? [])
-			.flatMap((group) => group.benchmarks ?? [])
-			.filter((candidate) => candidate.name === benchmark.name);
-
-		const averaged = { name: benchmark.name };
-		for (const field of numericFields) {
-			const values = peers
-				.map((peer) => peer[field])
-				.filter((value) => typeof value === "number");
-			if (values.length > 0) {
-				averaged[field] = values.reduce((sum, value) => sum + value, 0) / values.length;
-			}
-		}
-
-		return averaged;
-	});
-}
-
-export function buildBenchmarkHtml(benchHistory) {
-	const contexts = Object.entries(benchHistory.runs ?? {})
-		.filter(([, entry]) => Array.isArray(entry.runs) && entry.runs.length > 0)
-		.sort((a, b) => new Date(b[1].runs[0].date) - new Date(a[1].runs[0].date));
-
-	if (contexts.length === 0) {
-		return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Ark - Benchmarks</title>
-    <link rel="stylesheet" href="./styles.css" />
-  </head>
-  <body>
-    <main class="container">
-      <header class="hero">
-        <h1>Benchmarks</h1>
-        <p class="note">No benchmark history is available yet.</p>
-      </header>
-    </main>
-  </body>
-</html>
-`;
-	}
-
-	const rows = [];
-	for (const [, entry] of contexts) {
-		const benchmarks = averageBenchmarks(entry.runs);
-		const ctx = entry.context;
-		const environment = `${ctx.benchEnv ?? "unknown"}-${ctx.os.arch}`;
-		for (const benchmark of benchmarks) {
-			rows.push(`<tr>
-  <td>${environment}</td>
-  <td><code>${benchmark.name}</code></td>
-  <td>${fmtMs(benchmark.mean)}</td>
-  <td>${typeof benchmark.rme === "number" ? `±${benchmark.rme.toFixed(1)}%` : "-"}</td>
-  <td>${fmtMs(benchmark.p99)}</td>
-  <td>${fmtHz(benchmark.hz)}</td>
-  <td>${typeof benchmark.sampleCount === "number" ? Math.round(benchmark.sampleCount) : "-"}</td>
-</tr>`);
-		}
-	}
-
-	const details = contexts
-		.map(([, entry]) => {
-			const ctx = entry.context;
-			return `<li><strong>${ctx.benchEnv ?? "unknown"}-${ctx.os.arch}</strong> - ${ctx.os.platform} - ${ctx.cpu.model} x ${ctx.cpu.count} - ${ctx.memoryGb} GB - Node ${ctx.node} - rolling mean of ${entry.runs.length} run(s)</li>`;
-		})
-		.join("\n");
-
-	const updatedDate = contexts[0][1].runs[0].date.slice(0, 10);
-
-	return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Ark - Benchmarks</title>
-    <link rel="stylesheet" href="./styles.css" />
-  </head>
-  <body>
-    <main class="container">
-      <div class="hero">
-        <h1>Benchmarks</h1>
-        <p class="note">Updated ${updatedDate} · Branch: ${branch} · Commit: ${sha.slice(0, 12)}</p>
-      </div>
-      <section class="section">
-        <h2>Performance Table</h2>
-        <table>
-          <thead>
-            <tr>
-              <th>Environment</th>
-              <th>Benchmark</th>
-              <th>Mean</th>
-              <th>±RME</th>
-              <th>P99</th>
-              <th>Ops/s</th>
-              <th>Runs</th>
-            </tr>
-          </thead>
-          <tbody>
-            ${rows.join("\n")}
-          </tbody>
-        </table>
-      </section>
-      <section class="section">
-        <h2>Environment Notes</h2>
-        <ul>
-          ${details}
-        </ul>
-      </section>
-    </main>
-  </body>
-</html>
-`;
-}
-
-function buildStylesCss() {
-	return `:root {
-  --bg: #f4f7f3;
-  --surface: #ffffff;
-  --text: #132b24;
-  --muted: #4f6f65;
-  --accent: #0f9d72;
-  --accent-strong: #0d7f5c;
-  --border: #d6e3dd;
-  --shadow: 0 14px 40px rgba(12, 58, 45, 0.08);
-}
-* { box-sizing: border-box; }
-body { margin: 0; font-family: "Segoe UI", "Helvetica Neue", sans-serif; color: var(--text); background: radial-gradient(circle at top right, #dbefe7, var(--bg) 40%); }
-a { color: var(--accent-strong); }
-.container { max-width: 1100px; margin: 0 auto; padding: 28px 18px 60px; }
-.hero { background: linear-gradient(145deg, #183a31, #0e7f5c); color: #f3fff8; padding: 26px; border-radius: 18px; box-shadow: var(--shadow); }
-.hero h1 { margin: 6px 0 10px; }
-.note { color: #d8f5eb; margin: 0; }
-.section { margin-top: 26px; }
-table { width: 100%; border-collapse: collapse; background: var(--surface); border-radius: 12px; overflow: hidden; }
-th, td { border-bottom: 1px solid var(--border); padding: 9px 10px; text-align: left; }
-th { color: var(--muted); font-weight: 600; background: #f3faf7; }
-td code { color: var(--accent-strong); }
-@media (max-width: 700px) { .hero { padding: 20px; } .container { padding: 18px 12px 40px; } }
-`;
+/** Every badge file under `dir`, relative to it: the manifest restore-badges.mjs reads back. */
+async function listBadges(dir, prefix = "") {
+	const entries = await readdir(path.join(dir, prefix), { withFileTypes: true });
+	const nested = await Promise.all(
+		entries.map((entry) =>
+			entry.isDirectory()
+				? listBadges(dir, path.posix.join(prefix, entry.name))
+				: entry.name.endsWith(".svg")
+					? [path.posix.join(prefix, entry.name)]
+					: [],
+		),
+	);
+	return nested.flat().sort();
 }
 
 await rm(outputDir, { recursive: true, force: true });
-await mkdir(outputDir, { recursive: true });
+await mkdir(path.join(outputDir, "data"), { recursive: true });
 
 await writeFile(path.join(outputDir, "styles.css"), buildStylesCss());
 
 // index.html redirects to benchmark.html — no separate dashboard needed
 await writeFile(
 	path.join(outputDir, "index.html"),
-	`<!doctype html><html><head><meta charset="utf-8"/><meta http-equiv="refresh" content="0;url=./benchmark.html"/><title>Ark Pages</title></head><body><p><a href="./benchmark.html">Benchmarks</a></p></body></html>\n`,
+	`<!doctype html><html><head><meta charset="utf-8"/><meta http-equiv="refresh" content="0;url=./benchmark.html"/><title>Decohere Pages</title></head><body><p><a href="./benchmark.html">Benchmarks</a></p></body></html>\n`,
 );
 
-try {
-	const benchHistory = JSON.parse(await readFile(benchHistoryPath, "utf8"));
-	await writeFile(path.join(outputDir, "benchmark.html"), buildBenchmarkHtml(benchHistory));
-	const benchmarkDataDir = path.join(outputDir, "data");
-	await mkdir(benchmarkDataDir, { recursive: true });
-	await writeFile(
-		path.join(benchmarkDataDir, "bench-history.json"),
-		`${JSON.stringify(benchHistory, null, 2)}\n`,
-	);
-} catch {
-	await writeFile(path.join(outputDir, "benchmark.html"), buildBenchmarkHtml({ runs: {} }));
-}
+// No history yet (first deploy, or cleared) publishes the empty page, not a failure.
+const benchHistory = normalize(
+	existsSync(benchHistoryPath) ? JSON.parse(await readFile(benchHistoryPath, "utf8")) : null,
+);
+await writeFile(
+	path.join(outputDir, "benchmark.html"),
+	buildBenchmarkHtml(benchHistory, { branch, sha }),
+);
+await writeFile(
+	path.join(outputDir, "data", "bench-history.json"),
+	`${JSON.stringify(benchHistory, null, 2)}\n`,
+);
 
-try {
+// Badges are generated by earlier steps (CI status, coverage) or restored from the live site.
+if (existsSync(badgesDir)) {
 	await cp(badgesDir, path.join(outputDir, "badges"), { recursive: true });
-} catch {
-	// Badges may not exist yet for some runs.
+	const badges = await listBadges(badgesDir);
+	await writeFile(
+		path.join(outputDir, "badges", "manifest.json"),
+		`${JSON.stringify({ badges }, null, 2)}\n`,
+	);
 }
 
 await writeFile(path.join(outputDir, ".nojekyll"), "");