pulls.review 0.2.0 → 0.2.1

package/dist/client/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Allow: /

package/dist/devframe-CX5butdC.mjs

@@ -0,0 +1,493 @@
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { LOCAL_DEVFRAME_ID, LOCAL_RPC } from "@pulls.review/core/local-rpc";
+import { defineDevframe, defineRpcFunction } from "devframe";
+import { createLocalSource, readRepoInfo } from "@pulls.review/core/local";
+import { DiffsPayloadSchema } from "@pulls.review/core/types";
+import { execFile } from "node:child_process";
+import { githubTokenFromEnv } from "@pulls.review/core/env";
+import { resolve } from "node:path";
+import fsDriver from "unstorage/drivers/fs";
+//#region package.json
+var name = "pulls.review";
+var version = "0.2.1";
+const DEFAULT_CONFIG = {
+	lang: void 0,
+	message: void 0,
+	abortEarly: void 0,
+	abortPipeEarly: void 0
+};
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	if (!config$1 && true) return DEFAULT_CONFIG;
+	return {
+		lang: config$1?.lang ?? void 0,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? void 0,
+		abortPipeEarly: config$1?.abortPipeEarly ?? void 0
+	};
+}
+/**
+* Stringifies an unknown input to a literal or type string.
+*
+* @param input The unknown input.
+*
+* @returns A literal or type string.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+/**
+* Adds an issue to the dataset.
+*
+* @param context The issue context.
+* @param label The issue label.
+* @param dataset The input dataset.
+* @param config The configuration.
+* @param other The optional props.
+*
+* @internal
+*/
+function _addIssue(context, label, dataset, config$1, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config$1.lang,
+		abortEarly: config$1.abortEarly,
+		abortPipeEarly: config$1.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message$1 = other?.message ?? context.message ?? (context.reference, issue.lang, void 0) ?? (isSchema ? (issue.lang, void 0) : null) ?? config$1.message ?? (issue.lang, void 0);
+	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/**
+* Eagerly creates and attaches the Standard Schema properties of a schema.
+*
+* Hint: The contextual `this` type includes the standard properties that are
+* attached before the schema is returned.
+*
+* @param schema The schema to attach standard properties to.
+*
+* @returns The schema with standard properties attached.
+*
+* @internal
+*/
+function _standardSchema(schema) {
+	schema["~standard"] = {
+		version: 1,
+		vendor: "valibot",
+		validate: (value$1) => schema["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig())
+	};
+	return schema;
+}
+/**
+* Returns the fallback value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The output dataset if available.
+* @param config The config if available.
+*
+* @returns The fallback value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config$1) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message$1) {
+	return _standardSchema({
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function nullable(wrapped, default_) {
+	return _standardSchema({
+		kind: "schema",
+		type: "nullable",
+		reference: nullable,
+		expects: `(${wrapped.expects} | null)`,
+		async: false,
+		wrapped,
+		default: default_,
+		"~run"(dataset, config$1) {
+			if (dataset.value === null) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === null) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries$1, message$1) {
+	return _standardSchema({
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return _standardSchema({
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message$1) {
+	return _standardSchema({
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function void_(message$1) {
+	return _standardSchema({
+		kind: "schema",
+		type: "void",
+		reference: void_,
+		expects: "void",
+		async: false,
+		message: message$1,
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	});
+}
+//#endregion
+//#region src/credentials.ts
+/** The environment first, then the GitHub CLI's login, if `gh` is installed and signed in. */
+async function resolveGithubToken(env) {
+	const fromEnv = githubTokenFromEnv(env);
+	if (fromEnv) return fromEnv;
+	try {
+		const { stdout } = await promisify(execFile)("gh", ["auth", "token"]);
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/rpc.ts
+const target = /* @__PURE__ */ object({ target: /* @__PURE__ */ string() });
+/**
+* Every function the `PR_LOCAL` SPA calls. Only a client devframe has trusted
+* reaches them; inputs are still validated, since they decide what `git` runs.
+*/
+function localRpcFunctions({ cwd, driver, env }) {
+	const source = (text) => createLocalSource({
+		cwd,
+		target: text
+	});
+	return [
+		defineRpcFunction({
+			name: LOCAL_RPC.repoInfo,
+			type: "query",
+			handler: () => readRepoInfo(cwd)
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceKey,
+			type: "query",
+			args: [target],
+			returns: /* @__PURE__ */ string(),
+			handler: ({ target }) => source(target).key()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceFetch,
+			type: "query",
+			args: [target],
+			returns: DiffsPayloadSchema,
+			handler: ({ target }) => source(target).fetch()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceFingerprint,
+			type: "query",
+			args: [target],
+			returns: /* @__PURE__ */ string(),
+			handler: ({ target }) => source(target).fingerprint()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceLoadFile,
+			type: "query",
+			args: [/* @__PURE__ */ object({
+				target: /* @__PURE__ */ string(),
+				path: /* @__PURE__ */ string(),
+				sha: /* @__PURE__ */ string()
+			})],
+			returns: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+			handler: ({ target, path, sha }) => source(target).loadFile(path, sha)
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageGetItem,
+			type: "query",
+			args: [/* @__PURE__ */ object({ key: /* @__PURE__ */ string() })],
+			returns: /* @__PURE__ */ nullable(/* @__PURE__ */ string()),
+			handler: async ({ key }) => {
+				const value = await driver.getItem(key, {});
+				return typeof value === "string" ? value : null;
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageSetItem,
+			type: "action",
+			args: [/* @__PURE__ */ object({
+				key: /* @__PURE__ */ string(),
+				value: /* @__PURE__ */ string()
+			})],
+			returns: /* @__PURE__ */ void_(),
+			handler: async ({ key, value }) => {
+				await driver.setItem?.(key, value, {});
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageRemoveItem,
+			type: "action",
+			args: [/* @__PURE__ */ object({ key: /* @__PURE__ */ string() })],
+			returns: /* @__PURE__ */ void_(),
+			handler: async ({ key }) => {
+				await driver.removeItem?.(key, {});
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageGetKeys,
+			type: "query",
+			args: [/* @__PURE__ */ object({ base: /* @__PURE__ */ string() })],
+			returns: /* @__PURE__ */ array(/* @__PURE__ */ string()),
+			handler: ({ base }) => driver.getKeys(base, {})
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.githubToken,
+			type: "query",
+			handler: () => resolveGithubToken(env)
+		})
+	];
+}
+//#endregion
+//#region src/storage.ts
+/**
+* The fs driver maps every `:` of a key to a directory, so `a:b` (a file) and `a:b:c`
+* (needing `a/b/` as a directory) can't both exist. Keys stay one directory per
+* collection prefix (`pr-meta:`, `review:`, ...) with the rest escaped into one file name.
+*/
+function flatKeys(driver) {
+	const encode = (key) => {
+		const [head = "", ...rest] = key.split(":");
+		return rest.length ? `${head}:${encodeURIComponent(rest.join(":"))}` : head;
+	};
+	const decode = (key) => {
+		const [head = "", ...rest] = key.split(/[:/]/);
+		return rest.length ? `${head}:${decodeURIComponent(rest.join(":"))}` : head;
+	};
+	return {
+		...driver,
+		hasItem: (key, opts) => driver.hasItem(encode(key), opts),
+		getItem: (key, opts) => driver.getItem(encode(key), opts),
+		setItem: (key, value, opts) => driver.setItem?.(encode(key), value, opts),
+		removeItem: (key, opts) => driver.removeItem?.(encode(key), opts),
+		getKeys: async (base, opts) => (await driver.getKeys(encode(base.replace(/:$/, "")), opts)).map(decode)
+	};
+}
+/** `<git-common-dir>/pulls-review`: shared by every worktree of the repo, never committed. */
+async function repoCacheDir(cwd) {
+	const { stdout } = await promisify(execFile)("git", ["rev-parse", "--git-common-dir"], { cwd });
+	return resolve(cwd, stdout.trim(), "pulls-review");
+}
+async function createRepoCacheDriver(cwd) {
+	return flatKeys(fsDriver({ base: await repoCacheDir(cwd) }));
+}
+//#endregion
+//#region src/devframe.ts
+/**
+* The one definition every surface consumes: the `pulls.review` CLI (`index.ts`)
+* and, through `createPluginFromDevframe`, a devframe hub. The SPA is the app's
+* `PR_LOCAL` build, copied next to this file by the package build.
+*/
+var devframe_default = defineDevframe({
+	id: LOCAL_DEVFRAME_ID,
+	name: "pulls.review",
+	version,
+	packageName: name,
+	description: "Review local git changes, grouped and summarized.",
+	homepage: "https://pulls.review",
+	icon: "ph:git-diff-duotone",
+	clientAssets: fileURLToPath(new URL("./client", import.meta.url)),
+	importMetaUrl: import.meta.url,
+	cli: {
+		command: "pulls.review",
+		port: 7390
+	},
+	async setup(ctx) {
+		const scope = ctx.scope(LOCAL_DEVFRAME_ID);
+		const functions = localRpcFunctions({
+			cwd: ctx.cwd,
+			driver: await createRepoCacheDriver(ctx.cwd),
+			env: process.env
+		});
+		for (const fn of functions) scope.rpc.register(fn);
+	}
+});
+//#endregion
+export { devframe_default as t };

package/dist/devframe.mjs

@@ -0,0 +1,2 @@
+import { t as devframe_default } from "./devframe-CX5butdC.mjs";
+export { devframe_default as default };

package/dist/index.mjs

@@ -0,0 +1,90 @@
+import { t as devframe_default } from "./devframe-CX5butdC.mjs";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { createDevServer } from "devframe/adapters/dev";
+import { H3 } from "h3";
+import { isLocalBranch, parseTarget, readCurrentBranch, resolveDefaultBranch } from "@pulls.review/core/local";
+//#region src/page.ts
+/** The page an argument opens (see the app's local routes). */
+async function pageFor(cwd, arg, worktree) {
+	if (worktree) return "/worktree";
+	if (!arg) {
+		const [current, defaultBranch] = await Promise.all([readCurrentBranch(cwd), resolveDefaultBranch(cwd)]);
+		return current && defaultBranch && current !== defaultBranch.name ? `/branch/${current}` : "/";
+	}
+	if (parseTarget(arg).kind === "range") return `/compare/${arg}`;
+	return await isLocalBranch(cwd, arg) ? `/branch/${arg}` : `/commit/${arg}`;
+}
+//#endregion
+//#region src/index.ts
+const HELP = `Usage: pulls.review [target] [options]
+
+Reviews local git changes in the browser, grouped and summarized. Run it inside
+a git repository. The target only picks the page that opens; any other can be
+picked from the browser.
+
+Target (git revision syntax):
+  (none)     the current branch against the default branch, or the ref picker
+             when the default branch itself is checked out
+  <branch>   what a branch adds since it forked from the default branch
+  <rev>      one commit against its parent
+  A...B      what B adds since it forked from A
+  A..B       the tree diff between two revisions
+
+Options:
+  --worktree     open the uncommitted changes against HEAD
+  --port <port>  port to listen on
+  --no-open      do not open the browser
+  -h, --help
+
+To review a GitHub pull request in CI, use @pulls.review/actions.
+`;
+/**
+* devframe's SPA fallback skips any path that looks like a file, and refs do: `main...feat`
+* ends in `.feat`, `v1.2` in `.2`. Pages whose path carries a ref get the SPA's
+* `index.html` here, before devframe's static handler sees them.
+*/
+function createAppWithRefRoutes() {
+	const app = new H3();
+	const index = fileURLToPath(new URL("./client/index.html", import.meta.url));
+	app.use(async (event, next) => {
+		if (!/^\/(?:compare|branch|commit)\//.test(event.url.pathname) || !event.req.headers.get("accept")?.includes("text/html")) return next();
+		return new Response(await readFile(index, "utf8"), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+	});
+	return app;
+}
+async function main() {
+	const { values: flags, positionals } = parseArgs({
+		options: {
+			"worktree": { type: "boolean" },
+			"port": { type: "string" },
+			"no-open": { type: "boolean" },
+			"help": {
+				type: "boolean",
+				short: "h"
+			}
+		},
+		allowPositionals: true
+	});
+	if (flags.help) {
+		process.stdout.write(HELP);
+		return;
+	}
+	const page = encodeURI(await pageFor(process.cwd(), positionals[0], !!flags.worktree));
+	await createDevServer(devframe_default, {
+		app: createAppWithRefRoutes(),
+		port: flags.port ? Number(flags.port) : void 0,
+		openBrowser: flags["no-open"] ? false : page,
+		onReady: ({ origin }) => {
+			process.stdout.write(`pulls.review is serving ${origin}${page}\n`);
+		}
+	});
+}
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+});
+//#endregion
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pulls.review",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Review local git changes - the working tree, a commit or any range - grouped and summarized in the browser.",
   "author": "Anthony Fu <hi@antfu.me>",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@pulls.review/core": "^0.2.0",
+    "@pulls.review/core": "^0.2.1",
     "devframe": "^1.2.0",
     "h3": "^2.0.1-rc.32",
     "unstorage": "^1.17.5"