@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/change-set.ts

@@ -0,0 +1,105 @@
+/**
+ * The files `repo turn` gates: the index (`--staged`), the working tree against HEAD with the untracked files git
+ * does not ignore, or every file of one package. Each file carries the workspace package that owns it.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+/** Which files a turn covers; `rel` is root-relative POSIX, `""` for the root. */
+export type Scope = { kind: "staged" } | { kind: "tree" } | { kind: "package"; rel: string };
+/** One changed file; `owner` is the dir of the package owning it, `""` for the root. */
+export type Change = { rel: string; deleted: boolean; owner: string };
+export type ChangeSetResult = { ok: true; changes: Change[] } | { ok: false; errors: string[] };
+
+/** git's empty tree: what a repo with no commit yet diffs against. */
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+
+/** git in the root: its stdout, and whether it exited 0. */
+type Git = (args: string[]) => { ok: boolean; out: string };
+type Entry = { rel: string; deleted: boolean };
+type Entries = { ok: true; entries: Entry[] } | { ok: false; errors: string[] };
+
+function gitIn(root: string): Git {
+  return (args) => {
+    const run = spawnSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return { ok: run.status === 0, out: run.stdout };
+  };
+}
+
+/** The deepest package dir holding `rel`, or `""` for the root. */
+export function ownerOf(rel: string, packages: readonly string[]): string {
+  const holding = packages.filter((dir) => rel === dir || rel.startsWith(`${dir}/`));
+  return holding.sort((a, b) => a.length - b.length).at(-1) ?? "";
+}
+
+/** `--name-status -z` output as path and whether git saw it deleted. */
+function statuses(out: string): Entry[] {
+  const parts = out.split("\0").filter((part) => part !== "");
+  const entries: Entry[] = [];
+  for (let i = 0; i + 1 < parts.length; i += 2)
+    entries.push({ rel: parts[i + 1] as string, deleted: parts[i] === "D" });
+  return entries;
+}
+
+const names = (out: string): string[] => out.split("\0").filter((rel) => rel !== "");
+
+/** The base the working tree is compared to: HEAD, or the empty tree before the first commit. */
+function base(git: Git): string {
+  return git(["rev-parse", "--verify", "-q", "HEAD"]).ok ? "HEAD" : EMPTY_TREE;
+}
+
+const DIFF = ["--name-status", "-z", "--no-renames"];
+const UNTRACKED = ["ls-files", "--others", "--exclude-standard", "-z"];
+
+function staged(git: Git): Entries {
+  const index = statuses(git(["diff", "--cached", ...DIFF]).out);
+  const unstaged = new Set(names(git(["diff", "--name-only", "-z"]).out));
+  const partial = index.filter((entry) => unstaged.has(entry.rel));
+  if (partial.length === 0) return { ok: true, entries: index };
+  return {
+    ok: false,
+    errors: partial.map(
+      ({ rel }) => `${rel} has staged and unstaged changes; stage the rest (git add ${rel}) or undo it`,
+    ),
+  };
+}
+
+function tree(git: Git): Entries {
+  const tracked = statuses(git(["diff", base(git), ...DIFF]).out);
+  const untracked = names(git(UNTRACKED).out).map((rel) => ({ rel, deleted: false }));
+  return { ok: true, entries: [...tracked, ...untracked] };
+}
+
+/** Every file under `dir`, tracked or untracked; a tracked file missing from disk is a deletion. */
+function whole(git: Git, root: string, dir: string): Entries {
+  const listed = names(git(["ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", dir || "."]).out);
+  // An unmerged path is listed once per stage.
+  const entries = [...new Set(listed)].map((rel) => ({ rel, deleted: !fs.existsSync(path.join(root, rel)) }));
+  return { ok: true, entries };
+}
+
+/** A submodule or a nested checkout is a directory entry: listed by git, gated by its own repo. */
+function isDirectory(root: string, rel: string): boolean {
+  return rel.endsWith("/") || fs.lstatSync(path.join(root, rel), { throwIfNoEntry: false })?.isDirectory() === true;
+}
+
+function listOf({ git, root }: { git: Git; root: string }, scope: Scope, owner: string | null): Entries {
+  if (scope.kind === "staged") return staged(git);
+  return owner === null ? tree(git) : whole(git, root, owner);
+}
+
+/** The change set of `scope` under the git repo at `root`, sorted, each file with its owning package. */
+export function changeSet(root: string, scope: Scope, packages: readonly string[]): ChangeSetResult {
+  const git = gitIn(root);
+  if (!git(["rev-parse", "--git-dir"]).ok) return { ok: false, errors: [`${root} is not in a git repo`] };
+  const scopeOwner = scope.kind === "package" ? ownerOf(scope.rel, packages) : null;
+  const listed = listOf({ git, root }, scope, scopeOwner);
+  if (!listed.ok) return listed;
+  const changes = listed.entries
+    .filter((entry) => !isDirectory(root, entry.rel))
+    .map((entry) => ({ ...entry, owner: ownerOf(entry.rel, packages) }))
+    .filter((change) => scopeOwner === null || change.owner === scopeOwner)
+    .sort((a, b) => Number(a.rel > b.rel) - Number(a.rel < b.rel));
+  return { ok: true, changes };
+}

package/cli/scripts/check-globals.ts

@@ -0,0 +1,199 @@
+/**
+ * Assert every payload leaf in `agents/global-settings/` is present in its
+ * $HOME dest (generic subset check, skips keys matching `skipKeyPattern`), and
+ * that the project `.grok/config.toml` sets no [features] or [agent].
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { parse as parseToml } from "smol-toml";
+import { isRecord } from "./hook-input.ts";
+import {
+  type JsonObject,
+  hostIdsOf,
+  loadManifest,
+  readDest,
+  readPayload,
+  resolveDest,
+  shouldSkip,
+} from "./sync-global-settings.ts";
+import { readEnv } from "../env.ts";
+
+const APPLY_HINT = "run `bun repo yolo`";
+const PROJECT_REL = ".grok/config.toml";
+
+/** One settings key whose payload value is missing or different in the dest. */
+export interface DriftEntry {
+  host: string;
+  dest: string;
+  key: string;
+  kind: "missing" | "differs";
+}
+
+/** One host's check outcome: `ok`, drift (`missing`/`differs` entries), or an `unreadable` dest. */
+export interface HostStatus {
+  id: string;
+  dest: string;
+  state: "ok" | "drift" | "unreadable";
+  drift: DriftEntry[];
+}
+
+export interface CheckResult {
+  ok: boolean;
+  drift?: DriftEntry[];
+  error?: string;
+}
+
+type ProjectGrok = { error: string; value?: undefined } | { value: JsonObject; error?: undefined };
+
+function isPlainObject(v: unknown): v is JsonObject {
+  return v != null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date);
+}
+
+/** Leaf `[path, value]` pairs of a payload; arrays and dates are leaves. */
+function leaves(obj: JsonObject, skipRe: RegExp, prefix: string[] = []): [string[], unknown][] {
+  const out: [string[], unknown][] = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (shouldSkip(k, skipRe)) continue;
+    const next = [...prefix, k];
+    if (isPlainObject(v)) out.push(...leaves(v, skipRe, next));
+    else out.push([next, v]);
+  }
+  return out;
+}
+
+function valueAt(obj: unknown, keyPath: string[]): { found: false } | { found: true; value: unknown } {
+  let cur = obj;
+  for (const k of keyPath) {
+    if (!isPlainObject(cur) || !Object.prototype.hasOwnProperty.call(cur, k)) {
+      return { found: false };
+    }
+    cur = cur[k];
+  }
+  return { found: true, value: cur };
+}
+
+export function driftLine({ host, dest, key }: DriftEntry): string {
+  return `drift: ${host} ${dest} ${key}; ${APPLY_HINT}`;
+}
+
+function readProjectGrok(abs: string): ProjectGrok {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") return { error: "missing project .grok/config.toml" };
+    return { error: "unreadable project .grok/config.toml" };
+  }
+  try {
+    return { value: parseToml(raw) };
+  } catch {
+    return { error: "unreadable project .grok/config.toml" };
+  }
+}
+
+/** Per-host status for `host` ("all" or one id); an unreadable dest marks only its host. Throws on manifest or payload errors. */
+export function checkHosts({
+  home,
+  workspaceRoot,
+  sourceRoot,
+  consumerRoot,
+  host = "all",
+}: {
+  home: string;
+  workspaceRoot: string;
+  sourceRoot?: string | undefined;
+  consumerRoot?: string | undefined;
+  host?: string;
+}): HostStatus[] {
+  const src = sourceRoot || workspaceRoot;
+  const manifest = loadManifest(src);
+  if (!hostIdsOf(manifest).has(host)) throw new Error(`unknown host: ${host}`);
+  const skipRe = new RegExp(manifest.skipKeyPattern, "i");
+  const out: HostStatus[] = [];
+  for (const h of manifest.hosts.filter((x) => host === "all" || x.id === host)) {
+    const payload = readPayload(src, h, consumerRoot || workspaceRoot);
+    let destValue: JsonObject;
+    try {
+      destValue = readDest(resolveDest(home, h.dest), h.format, h.dest);
+    } catch {
+      out.push({ id: h.id, dest: h.dest, state: "unreadable", drift: [] });
+      continue;
+    }
+    const drift: DriftEntry[] = [];
+    for (const [keyPath, want] of leaves(payload, skipRe)) {
+      const have = valueAt(destValue, keyPath);
+      if (!have.found || !isDeepStrictEqual(have.value, want)) {
+        drift.push({ host: h.id, dest: h.dest, key: keyPath.join("."), kind: have.found ? "differs" : "missing" });
+      }
+    }
+    out.push({ id: h.id, dest: h.dest, state: drift.length ? "drift" : "ok", drift });
+  }
+  return out;
+}
+
+/** `grok ok · claude missing a,b differs c · …`: hosts in manifest order. */
+export function checkLine(statuses: HostStatus[]): string {
+  return statuses
+    .map((s) => {
+      if (s.state !== "drift") return `${s.id} ${s.state}`;
+      const parts = (["missing", "differs"] as const).flatMap((kind) => {
+        const keys = s.drift.filter((d) => d.kind === kind).map((d) => d.key);
+        return keys.length ? [`${kind} ${keys.join(",")}`] : [];
+      });
+      return `${s.id} ${parts.join(" ")}`;
+    })
+    .join(" · ");
+}
+
+/** The apply hint, shown only when some host has drifted. */
+export function checkHint(statuses: HostStatus[]): string | null {
+  return statuses.some((s) => s.state === "drift") ? APPLY_HINT : null;
+}
+
+/** The error for a project `.grok/config.toml` that is missing, unreadable or sets [features]/[agent]; null when fine or the same file as the home one. */
+export function projectConfigError(workspaceRoot: string, home: string): string | null {
+  const projectConfig = path.resolve(workspaceRoot, PROJECT_REL);
+  if (projectConfig === path.resolve(home, PROJECT_REL)) return null;
+  const project = readProjectGrok(projectConfig);
+  if (project.error !== undefined) return project.error;
+  if (
+    Object.prototype.hasOwnProperty.call(project.value, "features") ||
+    Object.prototype.hasOwnProperty.call(project.value, "agent")
+  ) {
+    return "project .grok/config.toml must not set [features] or [agent]";
+  }
+  return null;
+}
+
+/**
+ * Manifest and payloads come from `sourceRoot` (default `workspaceRoot`), each replaced by a file of its name under
+ * `consumerRoot`'s `.repo/global-settings/` (default `workspaceRoot`); the project `.grok/config.toml` from `workspaceRoot`.
+ */
+export function checkGlobals({
+  home,
+  workspaceRoot,
+  sourceRoot,
+  consumerRoot,
+}: {
+  home?: string;
+  workspaceRoot?: string;
+  sourceRoot?: string | undefined;
+  consumerRoot?: string | undefined;
+} = {}): CheckResult {
+  const homeDir = home || readEnv().HOME;
+  const ws = workspaceRoot || process.cwd();
+  if (!homeDir) return { ok: false, error: `HOME required; ${APPLY_HINT}` };
+  let statuses: HostStatus[];
+  try {
+    statuses = checkHosts({ home: homeDir, workspaceRoot: ws, sourceRoot, consumerRoot });
+  } catch (err) {
+    return { ok: false, error: (err /* checkHosts throws only Error values */ as Error).message };
+  }
+  const unreadable = statuses.find((s) => s.state === "unreadable");
+  if (unreadable) return { ok: false, error: `unreadable dest: ${unreadable.dest}; ${APPLY_HINT}` };
+  const drift = statuses.flatMap((s) => s.drift);
+  if (drift.length) return { ok: false, drift };
+  const error = projectConfigError(ws, homeDir);
+  return error === null ? { ok: true, drift } : { ok: false, error };
+}

package/cli/scripts/ci-skips.constants.ts

@@ -0,0 +1,17 @@
+/** Vitest reporters for a gate run that also writes the JSON the skip report is read from. */
+export const REPORT_REPORTERS: readonly string[] = ["--reporter=default", "--reporter=json"];
+/** The flag that sends the JSON reporter's output to a file; the file follows. */
+export const REPORT_OUTPUT_FLAG = "--outputFile.json=";
+/** The file name of the JSON report inside the temp directory. */
+export const REPORT_JSON_FILE = "vitest.json";
+/** The prefix of the temp directory the JSON report is written to. */
+export const REPORT_TEMP_PREFIX = "workerstack-ci-report-";
+/** Test statuses that mean the test did not run. */
+export const SKIPPED_STATUSES: readonly string[] = ["skipped", "pending", "todo"];
+/** Separates a test file from the full test name in a skip id. */
+export const ID_SEPARATOR = " > ";
+/** A report file a test job uploads. */
+export const REPORT_FILE: RegExp = /^ci-report-.*\.json$/;
+/** Reports needed before a test can be said to be skipped on every OS. */
+export const MIN_REPORTS = 2;
+export const REPORT_SHAPE = "expected { os: string, skipped: string[] }";

package/cli/scripts/ci-skips.ts

@@ -0,0 +1,118 @@
+/**
+ * The skip report of `repo ci --report <file>` and the check of `repo ci skips <dir>`. Each OS's test job writes the
+ * ids of the tests that did not run; a test skipped in every report runs in no CI job, which the check refuses.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { ID_SEPARATOR, MIN_REPORTS, REPORT_FILE, REPORT_SHAPE, SKIPPED_STATUSES } from "./ci-skips.constants.ts";
+
+/** Where relative paths start, and where lines go. */
+export type SkipsIo = { cwd: string; stdout: (s: string) => void; stderr: (s: string) => void };
+type Report = { os: string; skipped: string[] };
+
+const vitestReport = () =>
+  z.object({
+    testResults: z.array(
+      z.object({
+        name: z.string(),
+        assertionResults: z.array(z.object({ fullName: z.string(), status: z.string() })),
+      }),
+    ),
+  });
+const ciReport = () => z.object({ os: z.string().min(1), skipped: z.array(z.string()) });
+
+const posix = (file: string) => file.replaceAll("\\", "/");
+
+/** The ids of the tests vitest's JSON report says did not run, sorted and unique; the paths are root-relative posix. */
+export function skippedIds(json: unknown, root: string): string[] {
+  const parsed = vitestReport().safeParse(json);
+  if (!parsed.success) return [];
+  const ids = parsed.data.testResults.flatMap((file) =>
+    file.assertionResults
+      .filter((test) => SKIPPED_STATUSES.includes(test.status))
+      .map((test) => `${path.posix.relative(posix(root), posix(file.name))}${ID_SEPARATOR}${test.fullName}`),
+  );
+  return [...new Set(ids)].sort();
+}
+
+/** Writes `file` from the JSON report at `jsonFile`; a report that was not written or read has no skips. */
+export function writeReport(file: string, jsonFile: string, root: string): void {
+  let json: unknown = null;
+  try {
+    json = JSON.parse(fs.readFileSync(jsonFile, "utf8"));
+  } catch {
+    json = null;
+  }
+  const report: Report = { os: process.platform, skipped: skippedIds(json, root) };
+  fs.writeFileSync(file, `${JSON.stringify(report)}\n`);
+}
+
+/** The `ci-report-*.json` files of `dir` and of its subdirectories, as paths relative to `dir`. */
+function reportFiles(dir: string): string[] {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const nested = entries
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) =>
+      fs
+        .readdirSync(path.join(dir, entry.name), { withFileTypes: true })
+        .filter((inner) => inner.isFile() && REPORT_FILE.test(inner.name))
+        .map((inner) => `${entry.name}/${inner.name}`),
+    );
+  const top = entries.filter((entry) => entry.isFile() && REPORT_FILE.test(entry.name)).map((entry) => entry.name);
+  return [...top, ...nested].sort();
+}
+
+/** The report in `file`, or null with why it is not one. */
+function readReport(file: string): { report: Report | null; reason: string } {
+  let json: unknown;
+  try {
+    json = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return { report: null, reason: "not valid JSON" };
+  }
+  const parsed = ciReport().safeParse(json);
+  return { report: parsed.success ? parsed.data : null, reason: REPORT_SHAPE };
+}
+
+/** Reads every report in `dir`; failures are the lines to print, one per problem. */
+function readAll(dir: string, cwd: string): { reports: Report[] } | { failures: string[] } {
+  const at = path.resolve(cwd, dir);
+  let found: string[];
+  try {
+    found = reportFiles(at);
+  } catch {
+    return { failures: [`${dir} is not a directory; download the test jobs' reports into it first`] };
+  }
+  if (found.length === 0)
+    return { failures: [`${dir} has no ci-report-*.json; download the test jobs' reports first`] };
+  const read = found.map((rel) => ({ shown: `${dir}/${rel}`, got: readReport(path.join(at, rel)) }));
+  const failures = read
+    .filter(({ got }) => got.report === null)
+    .map(({ shown, got }) => `${shown} is not a ci report: ${got.reason}`);
+  if (failures.length > 0) return { failures };
+  return { reports: read.map(({ got }) => got.report).filter((report): report is Report => report !== null) };
+}
+
+/** `repo ci skips <dir>`: fails each test skipped in every report; `dir` is shown as given. */
+export function skipsMain(dir: string, io: SkipsIo): number {
+  const read = readAll(dir, io.cwd);
+  const fail = (lines: string[]) => {
+    for (const line of lines) io.stderr(`repo ci skips: ${line}\n`);
+    return 1;
+  };
+  if ("failures" in read) return fail(read.failures);
+  const oses = read.reports.map((report) => report.os).sort();
+  if (read.reports.length < MIN_REPORTS) {
+    return fail([`only ${read.reports.length} report (${oses.join(", ")}); every OS's test job must upload one`]);
+  }
+  const every = [...new Set(read.reports.flatMap((report) => report.skipped))];
+  const shared = every.filter((id) => read.reports.every((report) => report.skipped.includes(id)));
+  if (shared.length > 0) {
+    return fail(
+      shared.sort().map((id) => `${id} is skipped on every OS (${oses.join(", ")}); make it run on one or delete it`),
+    );
+  }
+  io.stdout(`ci skips: ${read.reports.length} reports (${oses.join(", ")}), no test skipped on all of them\n`);
+  return 0;
+}

package/cli/scripts/ci-wait-run.ts

@@ -0,0 +1,28 @@
+/** The real git and gh runners of `repo ci wait`, and its real sleep. */
+import { spawnSync } from "node:child_process";
+import { childEnv } from "../env.ts";
+import { toolEnv } from "./lint.ts";
+import type { Captured } from "./lint.ts";
+
+/** Runs a tool with `args` in a directory, its output captured. */
+export type Runner = (args: string[], cwd: string) => Captured;
+
+/** A runner of `bin`; a tool that cannot start is a failed run with the reason as its stderr. */
+export const spawnRunner =
+  (bin: string): Runner =>
+  (args, cwd) => {
+    const result = spawnSync(bin, args, { cwd, encoding: "utf8", env: toolEnv(childEnv()) });
+    if (result.error) return { code: 1, stdout: "", stderr: result.error.message };
+    return { code: result.status ?? 1, stdout: result.stdout, stderr: result.stderr };
+  };
+
+/** A runner of `bin` that shares this process's terminal, so the tool can prompt and its output is not captured. */
+export const inheritRunner =
+  (bin: string): Runner =>
+  (args, cwd) => {
+    const result = spawnSync(bin, args, { cwd, stdio: "inherit", env: toolEnv(childEnv()) });
+    if (result.error) return { code: 1, stdout: "", stderr: result.error.message };
+    return { code: result.status ?? 1, stdout: "", stderr: "" };
+  };
+
+export const realSleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));

package/cli/scripts/ci-wait.constants.ts

@@ -0,0 +1,44 @@
+/** Milliseconds between looks for the run, and how long to look before giving up. */
+export const POLL_MS = 10_000;
+export const GIVE_UP_MS = 120_000;
+export const MS_PER_SECOND = 1000;
+/** Characters of a sha shown. */
+export const SHA_SHOWN = 7;
+const WORKFLOW = "ci.yml";
+export const EXIT_PASSED = 0;
+export const EXIT_FAILED = 1;
+export const EXIT_SUPERSEDED = 2;
+/** Job conclusions that are not a failure. */
+export const NOT_FAILED: readonly string[] = ["success", "skipped", "neutral"];
+export const CONCLUSION_SUCCESS = "success";
+export const CONCLUSION_CANCELLED = "cancelled";
+export const GIT_HEAD: readonly string[] = ["rev-parse", "HEAD"];
+export const GIT_BRANCH: readonly string[] = ["rev-parse", "--abbrev-ref", "HEAD"];
+export const GIT_REMOTES = (sha: string): string[] => ["branch", "-r", "--contains", sha];
+export const GH_AUTH: readonly string[] = ["auth", "status"];
+const GH_LIST_FIELDS = "databaseId,status,conclusion,event,headBranch,createdAt";
+const GH_BRANCH_FIELDS = "databaseId,createdAt";
+const GH_VIEW_FIELDS = "conclusion,jobs";
+export const GH_LIST_COMMIT = (sha: string): string[] => [
+  "run",
+  "list",
+  "--commit",
+  sha,
+  "--workflow",
+  WORKFLOW,
+  "--json",
+  GH_LIST_FIELDS,
+];
+export const GH_LIST_BRANCH = (branch: string): string[] => [
+  "run",
+  "list",
+  "--branch",
+  branch,
+  "--workflow",
+  WORKFLOW,
+  "--json",
+  GH_BRANCH_FIELDS,
+];
+export const GH_WATCH = (id: number): string[] => ["run", "watch", String(id), "--exit-status"];
+export const GH_VIEW = (id: number): string[] => ["run", "view", String(id), "--json", GH_VIEW_FIELDS];
+export const GH_LOGS = (id: number): string[] => ["run", "view", String(id), "--log-failed"];