@stacknyu/pi-check 0.0.0-stage → 1.1.0

package/lib/client.mjs

@@ -0,0 +1,131 @@
+// Talk to the repo's broker, starting it when needed.
+import { spawn } from "node:child_process";
+import { chmodSync, mkdirSync, openSync, realpathSync, writeFileSync } from "node:fs";
+import http from "node:http";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { HOME_DIR, SHIM_DIR, STATE_DIR, VERSION, loadJson, pidAlive, repoRoots } from "./util.mjs";
+
+// Worktree plugin links must not publish a temporary worktree path in the global CLI registry.
+const HERE = realpathSync(dirname(fileURLToPath(import.meta.url)));
+export const BROKER = join(HERE, "broker.mjs");
+export const CLI = join(HERE, "..", "cli.mjs");
+export { SHIM_DIR };
+
+export function cleanPath(p = process.env.PATH ?? "") {
+	return p
+		.split(delimiter)
+		.filter((d) => d && resolve(d) !== resolve(SHIM_DIR))
+		.join(delimiter);
+}
+
+export function request(info, path, body, onEvent, timeoutMs, signal) {
+	return new Promise((res, rej) => {
+		const data = body === undefined ? undefined : JSON.stringify(body);
+		const req = http.request({ host: "127.0.0.1", port: info.port, path, method: data === undefined ? "GET" : "POST", signal, headers: { "x-pi-check-token": info.token, "content-type": "application/json" } }, (r) => {
+			r.on("error", rej);
+			let buf = "";
+			let last;
+			const nd = String(r.headers["content-type"] ?? "").includes("ndjson");
+			r.on("data", (d) => {
+				buf += d;
+				if (!nd) return;
+				let i;
+				while ((i = buf.indexOf("\n")) >= 0) {
+					const line = buf.slice(0, i);
+					buf = buf.slice(i + 1);
+					if (!line.trim()) continue;
+					try {
+						const ev = JSON.parse(line);
+						if (ev.type === "result" || ev.type === "error") last = ev;
+						else onEvent?.(ev);
+					} catch {}
+				}
+			});
+			r.on("end", () => {
+				if (nd) {
+					if (last?.type === "error") return rej(new Error(last.error));
+					return last ? res(last) : rej(new Error("broker closed the connection without a result"));
+				}
+				try {
+					const j = JSON.parse(buf || "{}");
+					if (r.statusCode >= 400) rej(new Error(j.error ?? `HTTP ${r.statusCode}`));
+					else res(j);
+				} catch (e) {
+					rej(e);
+				}
+			});
+		});
+		req.on("error", rej);
+		if (timeoutMs) req.setTimeout(timeoutMs, () => req.destroy(new Error("timeout")));
+		if (data !== undefined) req.write(data);
+		req.end();
+	});
+}
+
+async function ping(info) {
+	try {
+		const r = await request(info, "/ping", undefined, undefined, 2000);
+		return r?.ok ? r : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** -> { info, root, main } ; starts the broker unless start=false. */
+export async function connect(cwd, { start = true } = {}) {
+	const rr = repoRoots(cwd);
+	if (!rr) throw new Error(`${cwd} is not inside a git repository`);
+	const dir = join(rr.main, STATE_DIR);
+	const file = join(dir, "broker.json");
+	let info = loadJson(file);
+	if (info && pidAlive(info.pid)) {
+		const p = await ping(info);
+		if (!p) throw new Error("pi-check broker is alive but unresponsive; no duplicate broker was started");
+		if (p.version === VERSION) return { info, ...rr };
+		if (p && p.version !== VERSION) {
+			const status = await request(info, "/status", undefined, undefined, 3000);
+			if (status.running?.length || status.pending?.requested) {
+				throw new Error("pi-check upgrade pending: existing checks are still running; let them finish before reloading");
+			}
+			if (!start) return { info, ...rr };
+			// Only replace an idle broker; never kill another session's verification.
+			try {
+				await request(info, "/stop", {}, undefined, 3000);
+			} catch {}
+			await sleep(800);
+		}
+	}
+	if (!start) return { info: undefined, ...rr };
+	mkdirSync(dir, { recursive: true });
+	const log = openSync(join(dir, "broker.out"), "a");
+	const env = { ...process.env, PATH: cleanPath() };
+	delete env.PI_CHECK_SHIM_DIR;
+	spawn(process.execPath, [BROKER, rr.main], { cwd: rr.main, detached: true, stdio: ["ignore", log, log], env }).unref();
+	for (let i = 0; i < 100; i++) {
+		await sleep(150);
+		info = loadJson(file);
+		if (info && pidAlive(info.pid) && (await ping(info))) return { info, ...rr };
+	}
+	throw new Error(`pi-check broker did not start (see ${join(dir, "broker.out")})`);
+}
+
+export async function call(cwd, path, body, onEvent, opts = {}) {
+	opts.signal?.throwIfAborted();
+	const c = await connect(cwd, opts);
+	opts.signal?.throwIfAborted();
+	if (!c.info) return undefined;
+	return request(c.info, path, body === undefined ? undefined : { root: c.root, ...body }, onEvent, opts.timeoutMs, opts.signal);
+}
+
+/** `go` shim that routes `go test` / `go vet` through the broker. */
+export function installShims(node = process.execPath) {
+	mkdirSync(SHIM_DIR, { recursive: true });
+	const go = join(SHIM_DIR, "go");
+	writeFileSync(go, `#!/bin/sh\n# pi-check shim: go test / go vet go through the shared check broker; everything else is the real go.\nPI_CHECK_SHIM_DIR='${SHIM_DIR}' exec '${node}' '${CLI}' shim go "$@"\n`);
+	chmodSync(go, 0o755);
+	writeFileSync(join(HOME_DIR, "cli.json"), JSON.stringify({ cli: CLI, node, shims: SHIM_DIR, version: VERSION }, null, 2));
+	return SHIM_DIR;
+}

package/lib/commands.mjs

@@ -0,0 +1,27 @@
+// Which bash commands are checks (routed through the broker) and which run go test/vet (go shim).
+// Commands whose results depend only on the files: safe to share and replay.
+const RUNNER = /^(npx|bunx|pnpm(\s+(exec|dlx))?|yarn(\s+exec)?|bun\s+x)\s+/;
+const CHECK_TOOL = /^(vitest|jest|pytest|tsc|vue-tsc|eslint|oxlint|ruff|mypy|pyright)(\s|$)/;
+const PY_MODULE = /^((python3?|uv\s+run(\s+python3?)?|poetry\s+run(\s+python3?)?)\s+-m\s+(pytest|mypy|ruff)|(uv|poetry)\s+run\s+(pytest|mypy|ruff|pyright))(\s|$)/;
+const PKG_SCRIPT = /^(pnpm|npm|yarn|bun)\s+((-r|--recursive|-w|--filter\s+\S+|-F\s+\S+|--workspace\s+\S+|--prefix\s+\S+|-C\s+\S+|--dir\s+\S+|--silent|-s)\s+)*(run\s+)?(test|typecheck|type-check|lint|check|tsc|test:[\w:-]+|lint:[\w:-]+)(\s|$)/;
+// …unless they change files, watch, or install.
+const SIDE_EFFECTS = /--fix\b|--write\b|\s-u(\s|$)|--update(Snapshot)?\b|--watch\b|\bvitest\s+(watch|dev)\b|(npm|pnpm|yarn|bun|pip3?|uv|poetry)\s+(install|add|i|sync)\b|--init\b|\bformat\b|\bprettier\b|--generate|--emit\b|--build\b|\btsc\s+(-b|--build)\b|>\s*[\w./-]+\.(ts|tsx|js|py|go|json)\b/;
+
+export function segments(command) {
+	return command
+		.split(/&&|\|\||;|\||\n|\(|\)/)
+		.map((s) => s.trim().replace(/^(\w+=\S*\s+)+/, "").replace(/^(time|env|nice(\s+-n\s*-?\d+)?)\s+/, ""))
+		.filter(Boolean);
+}
+
+export function isCheckCommand(command) {
+	if (SIDE_EFFECTS.test(command)) return false;
+	return segments(command).some((seg) => {
+		const s = seg.replace(RUNNER, "");
+		return CHECK_TOOL.test(s) || PY_MODULE.test(seg) || PKG_SCRIPT.test(seg);
+	});
+}
+
+export function isGoCommand(command) {
+	return segments(command).some((s) => /^go\s+(test|vet)(\s|$)/.test(s) || /^(make|just|task|mage)(\s|$)/.test(s));
+}

package/lib/repo.mjs

@@ -0,0 +1,185 @@
+// A checkout (main repo or a worktree): its file listing, content digests, changed files, and the repo config.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CPUS, STATE_DIR, FileHasher, git, isUnder, loadJson, matchAny, sha } from "./util.mjs";
+
+export const CONFIG_FILE = "pi-check.json";
+
+const ALWAYS_SKIP = [".pi-queue/", ".pi-check/", ".pi-flow/", ".tasks/", ".git/"];
+
+export const DEFAULTS = {
+	maxJobs: 0, // 0 = available CPUs; independent from the number of agent sessions
+	cpuBudget: 0, // 0 = all available CPUs; a shared budget, not a utilization target
+	threads: 0, // 0 = divide spare budget among runnable jobs; positive = per-job ceiling
+	fastLane: true, // reserve one job slot and CPU for short checks when capacity permits
+	nice: 10,
+	watch: true,
+	speculate: true, // run affected checks ahead of time when files change
+	warmBase: false, // opt in to a full baseline warm-up; normal speculation is affected-only
+	speculateMaxLoad: 0.75, // only speculate while load average < cores * this
+	debounceMs: 2500,
+	intercept: "route", // route | block | off: what happens to raw test commands agents run in bash
+	shimGo: true, // `go test` / `go vet` inside agent shells go through the broker
+	base: "", // base branch for "changed" scope; default: the branch the main checkout is on
+	ignore: [], // globs never treated as check inputs (generated output, data dirs)
+	languages: { go: true, ts: true, python: true },
+	projects: {}, // "<dir>": { inputs: [...], exclude: [...], <kind>: false | { args, env, timeout, parallel, cmd, inputs } }
+	custom: [], // [{ name, cwd, cmd, inputs: [globs], timeout, env, parallel }]
+	groups: {}, // concurrency per group name, overrides defaults
+	idleMinutes: 180,
+	cacheDays: 21,
+	strict: false, // true: failures that also fail on the base branch still fail the check
+};
+
+export function loadConfig(main) {
+	const shared = loadJson(join(main, CONFIG_FILE), {}) ?? {};
+	const local = loadJson(join(main, STATE_DIR, "config.json"), {}) ?? {};
+	const c = { ...DEFAULTS, ...shared, ...local };
+	c.languages = { ...DEFAULTS.languages, ...(shared.languages ?? {}), ...(local.languages ?? {}) };
+	c.projects = { ...(shared.projects ?? {}), ...(local.projects ?? {}) };
+	c.groups = { ...(shared.groups ?? {}), ...(local.groups ?? {}) };
+	c.custom = [...(shared.custom ?? []), ...(local.custom ?? [])];
+	for (const key of ["cpuBudget", "maxJobs", "threads"]) {
+		if (!Number.isInteger(c[key]) || c[key] < 0) throw new Error(`${key} must be a non-negative integer`);
+	}
+	c.cpuBudget = c.cpuBudget || CPUS;
+	c.maxJobs = Math.min(c.maxJobs || c.cpuBudget, c.cpuBudget);
+	if (typeof c.fastLane !== "boolean") throw new Error("fastLane must be a boolean");
+	const laneOptions = [...c.custom, ...Object.values(c.projects).flatMap((p) => [p.test, p.vet, p.lint, p.typecheck, p.custom])];
+	for (const opts of laneOptions) if (opts?.lane !== undefined && !["fast", "heavy"].includes(opts.lane)) throw new Error("lane must be fast or heavy");
+	return c;
+}
+
+/** Per-project, per-kind options. `false` disables the kind. */
+export function kindOptions(config, projectDir, kind) {
+	const p = config.projects?.[projectDir] ?? config.projects?.[projectDir === "." ? "" : projectDir] ?? {};
+	const k = p[kind];
+	if (k === false) return false;
+	return { ...(k && typeof k === "object" ? k : {}), inputs: [...(p.inputs ?? []), ...((k && k.inputs) || [])], exclude: [...(p.exclude ?? []), ...((k && k.exclude) || [])] };
+}
+
+export class RootCtx {
+	constructor(abs, main, hasher = new FileHasher(), config = loadConfig(main)) {
+		this.abs = abs;
+		this.main = main;
+		this.isMain = abs === main;
+		this.hasher = hasher;
+		this.config = config;
+		this._listing = undefined;
+		this.version = 0;
+		this.memo = new Map(); // adapter memos, cleared on change
+	}
+
+	invalidate(structural = true) {
+		this.version++;
+		if (structural) this._listing = undefined;
+		this.memo.clear();
+	}
+
+	path(r) {
+		return r === "." ? this.abs : join(this.abs, r);
+	}
+
+	/** All files git would see (tracked + untracked, not ignored, not deleted), repo-relative. */
+	listing() {
+		if (this._listing) return this._listing;
+		const a = git(this.abs, ["ls-files", "-co", "--exclude-standard", "-z"]);
+		const d = git(this.abs, ["ls-files", "-d", "-z"]);
+		const deleted = new Set(d.out.split("\0").filter(Boolean));
+		const ignore = this.config.ignore ?? [];
+		const files = [];
+		const seen = new Set();
+		for (const f of a.out.split("\0")) {
+			if (!f || deleted.has(f) || seen.has(f)) continue;
+			if (ALWAYS_SKIP.some((s) => f.startsWith(s))) continue;
+			if (ignore.length && matchAny(ignore, f)) continue;
+			seen.add(f);
+			files.push(f);
+		}
+		files.sort();
+		this._listing = { files, set: seen, at: Date.now() };
+		return this._listing;
+	}
+
+	has(r) {
+		return this.listing().set.has(r);
+	}
+
+	filesUnder(dir, filter) {
+		const out = [];
+		for (const f of this.listing().files) if (isUnder(f, dir) && (!filter || filter(f))) out.push(f);
+		return out;
+	}
+
+	hash(r) {
+		if (this._hc) {
+			let h = this._hc.get(r);
+			if (h === undefined) this._hc.set(r, (h = this.hasher.hash(this.path(r))));
+			return h;
+		}
+		return this.hasher.hash(this.path(r));
+	}
+
+	/** Within fn, each file is stat'ed at most once (many units share inputs). */
+	batch(fn) {
+		const outer = this._hc;
+		if (!outer) this._hc = new Map();
+		try {
+			return fn();
+		} finally {
+			if (!outer) this._hc = undefined;
+		}
+	}
+
+	text(r) {
+		return this.hasher.text(this.path(r));
+	}
+
+	/** Digest of a set of repo-relative files: same contents => same digest, in any checkout. */
+	digest(files) {
+		const list = [...new Set(files)].sort();
+		const h = [];
+		for (const f of list) h.push(`${f}\0${this.hash(f)}`);
+		return sha(h.join("\n"));
+	}
+
+	/** Branch the main checkout has out (the queue's integration branch), or config.base. */
+	baseRef() {
+		if (this.config.base) return this.config.base;
+		const b = git(this.main, ["symbolic-ref", "--short", "-q", "HEAD"]);
+		return b.ok && b.out.trim() ? b.out.trim() : "HEAD";
+	}
+
+	/** Files changed vs the merge base with the base branch, plus uncommitted and untracked ones. */
+	changedFiles(baseRef = this.baseRef()) {
+		const mb = git(this.abs, ["merge-base", "HEAD", baseRef]);
+		const from = mb.ok ? mb.out.trim() : "HEAD";
+		const d = git(this.abs, ["diff", "--name-only", "-z", from]);
+		const u = git(this.abs, ["ls-files", "-o", "--exclude-standard", "-z"]);
+		const out = new Set();
+		for (const f of `${d.out}\0${u.out}`.split("\0")) if (f && !ALWAYS_SKIP.some((s) => f.startsWith(s))) out.add(f);
+		return out;
+	}
+
+	/** Uncommitted changes only (vs HEAD). */
+	dirtyFiles() {
+		const d = git(this.abs, ["diff", "--name-only", "-z", "HEAD"]);
+		const u = git(this.abs, ["ls-files", "-o", "--exclude-standard", "-z"]);
+		return new Set(`${d.out}\0${u.out}`.split("\0").filter((f) => f && !ALWAYS_SKIP.some((s) => f.startsWith(s))));
+	}
+
+	head() {
+		const h = git(this.abs, ["rev-parse", "HEAD"]);
+		return h.ok ? h.out.trim() : "";
+	}
+}
+
+export const LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb", "bun.lock", "go.work", "go.work.sum", "uv.lock", "poetry.lock", "Pipfile.lock"];
+
+export function rootLockfiles(rc) {
+	return LOCKFILES.filter((f) => rc.has(f));
+}
+
+export function exists(rc, r) {
+	return rc.has(r) || existsSync(rc.path(r));
+}