pulls.review 0.1.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 };