stim 1.14.0 → 1.16.0

package/dist/pull-request-pxnDCQzn.mjs

@@ -0,0 +1,322 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+//#region src/workspace/pull-request.ts
+const GH_TIMEOUT_MS = 2e4;
+const GH_ENV = {
+	GH_PROMPT_DISABLED: "1",
+	GH_NO_UPDATE_NOTIFIER: "1",
+	NO_COLOR: "1"
+};
+const GH_SCALAR_FIELDS = "number,state,url,headRefOid,mergedAt,closedAt,isCrossRepository,isDraft";
+const GH_FIELDS = `${GH_SCALAR_FIELDS},headRepository,headRepositoryOwner`;
+const GH_GRAPHQL_REPO_SELECTION = "headRepository { name } headRepositoryOwner { login }";
+const GH_DETAIL_FIELDS = "title reviewDecision commits(last: 1) { nodes { commit { statusCheckRollup { contexts(first: 0) { checkRunCountsByState { state count } statusContextCountsByState { state count } } } } } }";
+const SIGNED_OUT_EXIT = 4;
+const PASSING = /* @__PURE__ */ new Set([
+	"SUCCESS",
+	"NEUTRAL",
+	"SKIPPED",
+	"COMPLETED"
+]);
+const FAILING = /* @__PURE__ */ new Set([
+	"FAILURE",
+	"ERROR",
+	"TIMED_OUT",
+	"CANCELLED",
+	"ACTION_REQUIRED",
+	"STARTUP_FAILURE",
+	"STALE"
+]);
+const PENDING = /* @__PURE__ */ new Set([
+	"QUEUED",
+	"IN_PROGRESS",
+	"WAITING",
+	"PENDING",
+	"REQUESTED",
+	"EXPECTED"
+]);
+/** Sums a head commit's check runs and commit statuses by outcome; null when the commit has no checks. */
+function checkCounts(rollup) {
+	if (!rollup) return null;
+	const counts = {
+		passing: 0,
+		failing: 0,
+		pending: 0
+	};
+	const contexts = rollup.contexts;
+	for (const { state, count } of [...contexts?.checkRunCountsByState ?? [], ...contexts?.statusContextCountsByState ?? []]) {
+		if (!Number.isInteger(count) || count <= 0) continue;
+		if (PASSING.has(state)) counts.passing += count;
+		else if (FAILING.has(state)) counts.failing += count;
+		else if (PENDING.has(state)) counts.pending += count;
+	}
+	return counts;
+}
+function reviewDecisionOf(value) {
+	if (value === "APPROVED") return "approved";
+	if (value === "CHANGES_REQUESTED") return "changes-requested";
+	if (value === "REVIEW_REQUIRED") return "review-required";
+	return null;
+}
+function detailOf(pull) {
+	if (typeof pull.title !== "string") return {};
+	return {
+		title: pull.title,
+		reviewDecision: reviewDecisionOf(pull.reviewDecision),
+		checks: checkCounts(pull.commits?.nodes?.[0]?.commit?.statusCheckRollup)
+	};
+}
+function stateOf(state) {
+	if (state === "OPEN") return "open";
+	if (state === "MERGED") return "merged";
+	if (state === "CLOSED") return "closed";
+	return null;
+}
+function epoch(text) {
+	const at = text ? Date.parse(text) : NaN;
+	return Number.isFinite(at) ? at : null;
+}
+function headRepoOf(pull) {
+	const owner = pull.headRepositoryOwner?.login;
+	const name = pull.headRepository?.name;
+	return owner && name ? `${owner.toLowerCase()}/${name.toLowerCase()}` : null;
+}
+/**
+* Picks the pull request that describes `head` among those `gh pr list --head <branch>` returned. One whose head is
+* `head` wins, then one whose head contains `head`, then one whose head `head` contains. An open one wins a tier,
+* then the newest. A pull request unrelated to `head` is from an earlier use of the branch name and is ignored. A
+* cross-repository pull request is kept only when its head repository is one of `ownRepos` (this checkout's own git
+* remotes, lowercased "owner/name"); otherwise it only shares the branch name with a stranger's fork and is ignored.
+* `isAncestor(a, b)` answers whether commit `a` is an ancestor of commit `b`, and false when git cannot tell.
+*/
+function selectPullRequest(pulls, head, isAncestor, ownRepos = /* @__PURE__ */ new Set()) {
+	const known = pulls.flatMap((pull) => {
+		if (!pull || typeof pull !== "object") return [];
+		const state = stateOf(pull.state);
+		if (!state || !pull.headRefOid) return [];
+		if (pull.isCrossRepository) {
+			const repo = headRepoOf(pull);
+			if (!repo || !ownRepos.has(repo)) return [];
+		}
+		return [{
+			pull,
+			state
+		}];
+	});
+	const tiers = [
+		known.filter(({ pull }) => pull.headRefOid === head),
+		known.filter(({ pull }) => pull.headRefOid !== head && isAncestor(head, pull.headRefOid)),
+		known.filter(({ pull }) => pull.headRefOid !== head && isAncestor(pull.headRefOid, head))
+	];
+	const tier = tiers.findIndex((entries) => entries.length > 0);
+	if (tier < 0) return null;
+	const { pull, state } = tiers[tier].toSorted((a, b) => Number(b.state === "open") - Number(a.state === "open") || b.pull.number - a.pull.number)[0];
+	return {
+		number: pull.number,
+		state,
+		draft: pull.isDraft === true,
+		url: pull.url,
+		head: pull.headRefOid,
+		containsHead: tier < 2,
+		endedAt: state === "merged" ? epoch(pull.mergedAt) : state === "closed" ? epoch(pull.closedAt) : null,
+		...detailOf(pull)
+	};
+}
+function firstLine(error) {
+	const { stderr, message } = error;
+	const text = String(stderr ?? "").trim() || String(message ?? error);
+	return text.split("\n")[0] ?? text;
+}
+function ghFailure(error, command) {
+	if (error.status === SIGNED_OUT_EXIT) return {
+		unavailable: "gh is not signed in; run `gh auth login`",
+		sticky: true
+	};
+	if (error.code === "ETIMEDOUT") return {
+		unavailable: `${command} did not answer within ${GH_TIMEOUT_MS / 1e3}s`,
+		sticky: true
+	};
+	return {
+		unavailable: `${command} failed: ${firstLine(error)}`,
+		sticky: false
+	};
+}
+function ancestry(cwd) {
+	const exec = getExecutor();
+	return (ancestor, descendant) => exec.runFileQuiet("git", [
+		"-C",
+		cwd,
+		"merge-base",
+		"--is-ancestor",
+		ancestor,
+		descendant
+	]) !== null;
+}
+const REMOTE_URL_RE = /^(?:https?:\/\/(?:[^/@]+@)?[^/]+\/|ssh:\/\/(?:[^/@]+@)?[^/]+\/|(?:[^/@:]+@)?[^/:]+:)([^/]+)\/([^/]+?)(?:\.git)?\/?$/i;
+/**
+* "owner/name", lowercased, parsed out of a git remote URL, or null when it doesn't match: https, `ssh://`, or
+* scp-like (`[user@]host:owner/name`, which also covers an `~/.ssh/config` host alias in place of `user@host`).
+*/
+function parseRemoteRepo(url) {
+	const [, owner, name] = REMOTE_URL_RE.exec(url.trim()) ?? [];
+	return owner && name ? `${owner.toLowerCase()}/${name.toLowerCase()}` : null;
+}
+function localRemoteRepos(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"remote",
+		"-v"
+	]);
+	const repos = /* @__PURE__ */ new Set();
+	for (const line of out ? out.split("\n") : []) {
+		const url = /^\S+\s+(\S+)\s+\((?:fetch|push)\)$/.exec(line)?.[1];
+		const repo = url ? parseRemoteRepo(url) : null;
+		if (repo) repos.add(repo);
+	}
+	return repos;
+}
+/**
+* Asks GitHub, through `gh`, which pull requests have `branch` as their head, run from `cwd` so `gh` picks the
+* repository from its remotes. Each call is one fixed `gh pr list` invocation. Once `gh` is missing, signed out or
+* times out, every later lookup through the same function answers `unavailable` without running it again.
+*/
+function pullRequestLookup() {
+	let unavailable;
+	return (cwd, branch, head) => {
+		const exec = getExecutor();
+		if (unavailable === void 0) unavailable = exec.findExecutable("gh") ? null : "gh is not installed";
+		if (unavailable) return { unavailable };
+		let out;
+		try {
+			out = exec.runFile("gh", [
+				"pr",
+				"list",
+				"--head",
+				branch,
+				"--state",
+				"all",
+				"--limit",
+				"20",
+				"--json",
+				GH_FIELDS
+			], {
+				cwd,
+				timeoutMs: GH_TIMEOUT_MS,
+				env: GH_ENV
+			});
+		} catch (error) {
+			const failure = ghFailure(error, "gh pr list");
+			if (failure.sticky) unavailable = failure.unavailable;
+			return { unavailable: failure.unavailable };
+		}
+		let pulls;
+		try {
+			pulls = JSON.parse(out);
+		} catch {
+			return { unavailable: "gh pr list printed no JSON" };
+		}
+		return { pullRequest: Array.isArray(pulls) ? selectPullRequest(pulls, head, ancestry(cwd), localRemoteRepos(cwd)) : null };
+	};
+}
+function branchesQuery(count, detail) {
+	const variables = Array.from({ length: count }, (_, i) => `, $b${i}: String!`).join("");
+	const nodes = `${GH_SCALAR_FIELDS.replaceAll(",", " ")} ${GH_GRAPHQL_REPO_SELECTION}` + (detail ? ` ${GH_DETAIL_FIELDS}` : "");
+	return `query($owner: String!, $repo: String!${variables}) { repository(owner: $owner, name: $repo) {${Array.from({ length: count }, (_, i) => ` b${i}: pullRequests(headRefName: $b${i}, states: [OPEN, CLOSED, MERGED], first: 20, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { ${nodes} } }`).join("")} } }`;
+}
+/**
+* {@link pullRequestLookup} for every branch of one repository in one fixed `gh api graphql` call run from `repo`,
+* which asks for the same 20 newest pull requests of each head branch that `gh pr list --head` returns. `gh` fills
+* `{owner}` and `{repo}` from the remotes of `repo`; branch names travel as variables. Once `gh` is missing, signed
+* out or times out, every later call through the same function answers `unavailable` without running it again.
+* With `detail`, it also asks for each pull request's title, review decision and head commit check counts.
+*/
+function pullRequestLookups({ detail = false } = {}) {
+	let unavailable;
+	return async (repo, queries) => {
+		const exec = getExecutor();
+		if (unavailable === void 0) unavailable = exec.findExecutable("gh") ? null : "gh is not installed";
+		const all = (lookup) => queries.map(() => lookup);
+		if (unavailable) return all({ unavailable });
+		if (!queries.length) return [];
+		const args = [
+			"api",
+			"graphql",
+			"-F",
+			"owner={owner}",
+			"-F",
+			"repo={repo}"
+		];
+		queries.forEach(({ branch }, i) => args.push("-f", `b${i}=${branch}`));
+		args.push("-f", `query=${branchesQuery(queries.length, detail)}`);
+		let out;
+		try {
+			out = await exec.runFileAsync("gh", args, {
+				cwd: repo,
+				timeoutMs: GH_TIMEOUT_MS,
+				env: GH_ENV
+			});
+		} catch (error) {
+			const failure = ghFailure(error, "gh api graphql");
+			if (failure.sticky) unavailable = failure.unavailable;
+			return all({ unavailable: failure.unavailable });
+		}
+		let found;
+		try {
+			found = JSON.parse(out).data?.repository;
+		} catch {
+			return all({ unavailable: "gh api graphql printed no JSON" });
+		}
+		if (!found) return all({ unavailable: "gh api graphql printed no repository" });
+		const ownRepos = localRemoteRepos(repo);
+		return queries.map(({ cwd, head }, i) => {
+			const pulls = found[`b${i}`]?.nodes;
+			return { pullRequest: Array.isArray(pulls) ? selectPullRequest(pulls, head, ancestry(cwd), ownRepos) : null };
+		});
+	};
+}
+/** The merged or closed pull request whose commits include HEAD, which makes the worktree removable. */
+function endedPullRequest(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	return pr && pr.state !== "open" && pr.containsHead ? pr : null;
+}
+/** "PR #123 merged", for reports. */
+function describePullRequest(pr) {
+	return `PR #${pr.number} ${pr.state}`;
+}
+/**
+* Looks up the pull request of each worktree's branch and HEAD, with one {@link pullRequestLookups} call per
+* repository. The map holds null for a worktree without one, and leaves out a worktree whose HEAD git cannot read
+* or whose lookup was unavailable.
+*/
+function worktreePullRequests() {
+	const lookup = pullRequestLookups();
+	return async (worktrees) => {
+		const exec = getExecutor();
+		const repos = /* @__PURE__ */ new Map();
+		for (const { path, branch, repository } of worktrees) {
+			let head;
+			try {
+				head = (await exec.runFileAsync("git", [
+					"-C",
+					path,
+					"rev-parse",
+					"HEAD"
+				], { timeoutMs: 5e3 })).trim();
+			} catch {
+				continue;
+			}
+			repos.set(repository, [...repos.get(repository) ?? [], {
+				cwd: path,
+				branch,
+				head
+			}]);
+		}
+		const found = /* @__PURE__ */ new Map();
+		for (const [repo, queries] of repos) (await lookup(repo, queries)).forEach((result, i) => {
+			if ("pullRequest" in result) found.set(queries[i].cwd, result.pullRequest);
+		});
+		return found;
+	};
+}
+//#endregion
+export { pullRequestLookup as a, worktreePullRequests as c, parseRemoteRepo as i, describePullRequest as n, pullRequestLookups as o, endedPullRequest as r, selectPullRequest as s, checkCounts as t };

package/dist/pull-requests.d.mts

@@ -0,0 +1,120 @@
+//#region src/workspace/pull-request.d.ts
+interface GhPullRequest {
+  number: number;
+  state: string;
+  url: string;
+  headRefOid: string;
+  mergedAt: string | null;
+  closedAt: string | null;
+  isCrossRepository?: boolean;
+  isDraft?: boolean;
+  headRepository?: {
+    name?: string | null;
+  } | null;
+  headRepositoryOwner?: {
+    login?: string | null;
+  } | null;
+  title?: string;
+  reviewDecision?: string | null;
+  commits?: {
+    nodes?: {
+      commit?: {
+        statusCheckRollup?: GhCheckRollup | null;
+      };
+    }[];
+  };
+}
+interface GhStateCount {
+  state: string;
+  count: number;
+}
+interface GhCheckRollup {
+  contexts?: {
+    checkRunCountsByState?: GhStateCount[];
+    statusContextCountsByState?: GhStateCount[];
+  };
+}
+interface CheckCounts {
+  passing: number;
+  failing: number;
+  pending: number;
+}
+/**
+ * The pull request whose head branch is the worktree's branch and whose commits include the worktree's HEAD.
+ * `containsHead` is false when the pull request's head is an ancestor of HEAD: HEAD has commits the pull request
+ * never had. `endedAt` is when it was merged or closed, in epoch milliseconds, and null while it is open.
+ */
+interface PullRequestFact {
+  number: number;
+  state: "open" | "merged" | "closed";
+  draft: boolean;
+  url: string;
+  head: string;
+  containsHead: boolean;
+  endedAt: number | null;
+  /** Present when the lookup asked for detail. */
+  title?: string;
+  reviewDecision?: "approved" | "changes-requested" | "review-required" | null;
+  checks?: CheckCounts | null;
+}
+/** Sums a head commit's check runs and commit statuses by outcome; null when the commit has no checks. */
+declare function checkCounts(rollup: GhCheckRollup | null | undefined): CheckCounts | null;
+type PullRequestLookup = {
+  pullRequest: PullRequestFact | null;
+} | {
+  unavailable: string;
+};
+/**
+ * Picks the pull request that describes `head` among those `gh pr list --head <branch>` returned. One whose head is
+ * `head` wins, then one whose head contains `head`, then one whose head `head` contains. An open one wins a tier,
+ * then the newest. A pull request unrelated to `head` is from an earlier use of the branch name and is ignored. A
+ * cross-repository pull request is kept only when its head repository is one of `ownRepos` (this checkout's own git
+ * remotes, lowercased "owner/name"); otherwise it only shares the branch name with a stranger's fork and is ignored.
+ * `isAncestor(a, b)` answers whether commit `a` is an ancestor of commit `b`, and false when git cannot tell.
+ */
+declare function selectPullRequest(pulls: readonly GhPullRequest[], head: string, isAncestor: (ancestor: string, descendant: string) => boolean, ownRepos?: ReadonlySet<string>): PullRequestFact | null;
+/**
+ * "owner/name", lowercased, parsed out of a git remote URL, or null when it doesn't match: https, `ssh://`, or
+ * scp-like (`[user@]host:owner/name`, which also covers an `~/.ssh/config` host alias in place of `user@host`).
+ */
+declare function parseRemoteRepo(url: string): string | null;
+/**
+ * Asks GitHub, through `gh`, which pull requests have `branch` as their head, run from `cwd` so `gh` picks the
+ * repository from its remotes. Each call is one fixed `gh pr list` invocation. Once `gh` is missing, signed out or
+ * times out, every later lookup through the same function answers `unavailable` without running it again.
+ */
+declare function pullRequestLookup(): (cwd: string, branch: string, head: string) => PullRequestLookup;
+/** A worktree whose pull request {@link pullRequestLookups} looks up: its path, branch and HEAD commit. */
+interface PullRequestQuery {
+  cwd: string;
+  branch: string;
+  head: string;
+}
+/**
+ * {@link pullRequestLookup} for every branch of one repository in one fixed `gh api graphql` call run from `repo`,
+ * which asks for the same 20 newest pull requests of each head branch that `gh pr list --head` returns. `gh` fills
+ * `{owner}` and `{repo}` from the remotes of `repo`; branch names travel as variables. Once `gh` is missing, signed
+ * out or times out, every later call through the same function answers `unavailable` without running it again.
+ * With `detail`, it also asks for each pull request's title, review decision and head commit check counts.
+ */
+declare function pullRequestLookups({ detail }?: {
+  detail?: boolean;
+}): (repo: string, queries: readonly PullRequestQuery[]) => Promise<PullRequestLookup[]>;
+/** The merged or closed pull request whose commits include HEAD, which makes the worktree removable. */
+declare function endedPullRequest(lookup: PullRequestLookup | null): PullRequestFact | null;
+/** "PR #123 merged", for reports. */
+declare function describePullRequest(pr: Pick<PullRequestFact, "number" | "state">): string;
+/** A linked worktree whose pull request {@link worktreePullRequests} looks up. */
+interface WorktreeBranch {
+  path: string;
+  branch: string;
+  repository: string;
+}
+/**
+ * Looks up the pull request of each worktree's branch and HEAD, with one {@link pullRequestLookups} call per
+ * repository. The map holds null for a worktree without one, and leaves out a worktree whose HEAD git cannot read
+ * or whose lookup was unavailable.
+ */
+declare function worktreePullRequests(): (worktrees: readonly WorktreeBranch[]) => Promise<Map<string, PullRequestFact | null>>;
+//#endregion
+export { CheckCounts, GhCheckRollup, GhPullRequest, PullRequestFact, PullRequestLookup, PullRequestQuery, WorktreeBranch, checkCounts, describePullRequest, endedPullRequest, parseRemoteRepo, pullRequestLookup, pullRequestLookups, selectPullRequest, worktreePullRequests };

package/dist/pull-requests.mjs

@@ -0,0 +1,2 @@
+import { a as pullRequestLookup, c as worktreePullRequests, i as parseRemoteRepo, n as describePullRequest, o as pullRequestLookups, r as endedPullRequest, s as selectPullRequest, t as checkCounts } from "./pull-request-pxnDCQzn.mjs";
+export { checkCounts, describePullRequest, endedPullRequest, parseRemoteRepo, pullRequestLookup, pullRequestLookups, selectPullRequest, worktreePullRequests };

package/dist/recordings-BIXOzVnr.mjs

@@ -0,0 +1,37 @@
+import { at as gitCommonDirOnDisk } from "./settings-oTSkkNrM.mjs";
+import { existsSync, rmSync } from "node:fs";
+import { loadConfig, recordingEnabled, workspaceRecordingsDir } from "@stim-cli/core/state";
+//#region src/workspace/recordings.ts
+/** `recording.enabled` for one registered workspace, from `STIM_RECORDING` and its workspace, repo and machine layers. */
+function workspaceRecordingEnabled(path, project, config, env) {
+	const repo = gitCommonDirOnDisk(path);
+	return recordingEnabled(env, [
+		project.settings,
+		repo ? config?.repos?.[repo]?.settings : void 0,
+		config
+	]);
+}
+/** Every registered workspace's `recording.enabled` from the settings files alone, without `STIM_RECORDING`. */
+function recordingLayers() {
+	const config = loadConfig();
+	return new Map(Object.entries(config?.projects ?? {}).map(([path, project]) => [path, workspaceRecordingEnabled(path, project, config, {})]));
+}
+/**
+* Deletes the recordings of every workspace a settings write turned off, comparing the settings files before
+* (`before`, from {@link recordingLayers}) and after it, and returns those workspaces. stim-server stops
+* recording them once `stim status` shows the change.
+*/
+function deleteTurnedOffRecordings(before) {
+	return [...recordingLayers()].flatMap(([path, enabled]) => {
+		if (enabled || before.get(path) === false) return [];
+		const dir = workspaceRecordingsDir(path);
+		if (!existsSync(dir)) return [];
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		return [path];
+	});
+}
+//#endregion
+export { recordingLayers as n, workspaceRecordingEnabled as r, deleteTurnedOffRecordings as t };