@nulab/bee 0.0.0 → 1.0.0-rc.0

package/dist/shared/bee.CCNmDHVv.mjs

@@ -0,0 +1,33 @@
+const ACTIVITY_LABELS = {
+  1: "Issue Created",
+  2: "Issue Updated",
+  3: "Issue Commented",
+  4: "Issue Deleted",
+  5: "Wiki Created",
+  6: "Wiki Updated",
+  7: "Wiki Deleted",
+  8: "File Added",
+  9: "File Updated",
+  10: "File Deleted",
+  11: "SVN Committed",
+  12: "Git Pushed",
+  13: "Git Repo Created",
+  14: "Issue Multi-Updated",
+  15: "Project User Added",
+  16: "Project User Removed",
+  17: "Notification Added",
+  18: "Pull Request Added",
+  19: "Pull Request Updated",
+  20: "Pull Request Commented",
+  21: "Pull Request Deleted",
+  22: "Milestone Added",
+  23: "Milestone Updated",
+  24: "Milestone Deleted",
+  25: "Project Team Added",
+  26: "Project Team Deleted",
+  34: "Status Deleted",
+  35: "Issues Dates Updated",
+  47: "Issue Multi-Created"
+};
+
+export { ACTIVITY_LABELS as A };

package/dist/shared/bee.CQ3kBgas.mjs

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { colorize } from 'consola/utils';
+
+class BeeCommand extends Command {
+  beeExamples = [];
+  beeEnvVars = [];
+  helpInformation() {
+    return super.helpInformation() + this._renderExamples() + this._renderEnvVars();
+  }
+  createCommand(name) {
+    return new BeeCommand(name);
+  }
+  examples(examples) {
+    this.beeExamples.push(...examples);
+    return this;
+  }
+  envVars(vars) {
+    this.beeEnvVars.push(...vars);
+    return this;
+  }
+  async addCommands(mods) {
+    const resolved = await Promise.all(mods);
+    for (const mod of resolved) {
+      this.addCommand(mod.default);
+    }
+    return this;
+  }
+  _renderExamples() {
+    if (this.beeExamples.length === 0) {
+      return "";
+    }
+    const lines = this.beeExamples.flatMap((ex) => [
+      `  # ${ex.description}`,
+      `  $ ${ex.command}`,
+      ""
+    ]);
+    return `
+${colorize("bold", "EXAMPLES")}
+${lines.join("\n")}`;
+  }
+  _renderEnvVars() {
+    const fromOptions = this.options.filter((opt) => opt.envVar).map((opt) => [opt.envVar, opt.description ?? ""]);
+    const vars = [...fromOptions, ...this.beeEnvVars];
+    if (vars.length === 0) {
+      return "";
+    }
+    const maxLen = Math.max(...vars.map(([k]) => k.length));
+    const lines = vars.map(([k, d]) => `  ${k.padEnd(maxLen + 3)}${d}`);
+    return `
+${colorize("bold", "ENVIRONMENT VARIABLES")}
+${lines.join("\n")}`;
+  }
+}
+const ENV_AUTH = [["BACKLOG_API_KEY", "Authenticate with an API key"]];
+const ENV_PROJECT = ["BACKLOG_PROJECT", "Default project ID or project key"];
+const ENV_REPO = ["BACKLOG_REPO", "Default repository name"];
+
+export { BeeCommand as B, ENV_AUTH as E, ENV_PROJECT as a, ENV_REPO as b };

package/dist/shared/bee.CThuQMit.mjs

@@ -0,0 +1,124 @@
+import consola from 'consola';
+import { U as UserError } from './bee.XxOB1Her.mjs';
+import 'node:stream/consumers';
+import 'valibot';
+import { Backlog } from 'backlog-js';
+import { r as refreshAccessToken } from './bee.CktwmH8R.mjs';
+import { l as loadConfig } from './bee.DVTuFf-T.mjs';
+import { f as findSpace, u as updateSpaceAuth } from './bee.-8tk76YJ.mjs';
+
+const formatResetTime = (epochSeconds) => {
+  const date = new Date(epochSeconds * 1e3);
+  return date.toString();
+};
+
+const getClient = async (host) => {
+  const config = loadConfig();
+  const resolvedHost = host ?? config.defaultSpace;
+  if (!resolvedHost) {
+    throw new UserError("No space configured. Run `bee auth login` to authenticate.");
+  }
+  const resolved = findSpace(config.spaces, resolvedHost);
+  if (!resolved) {
+    throw new UserError(
+      `Space "${resolvedHost}" not found. Run \`bee auth login\` to authenticate.`
+    );
+  }
+  if (resolved.auth.method === "api-key") {
+    const client = new Backlog({
+      host: resolved.host,
+      apiKey: resolved.auth.apiKey
+    });
+    return { client, host: resolved.host };
+  }
+  return {
+    client: createOAuthClient(resolved.host, resolved.auth),
+    host: resolved.host
+  };
+};
+const createOAuthClient = (host, oauthAuth) => {
+  let currentClient = new Backlog({ host, accessToken: oauthAuth.accessToken });
+  let refreshPromise = null;
+  const refreshTokenIfNeeded = async () => {
+    if (refreshPromise) {
+      const result2 = await refreshPromise;
+      if (!result2) {
+        throw new UserError(
+          "OAuth session has expired. Run `bee auth login -m oauth` to re-authenticate."
+        );
+      }
+      return;
+    }
+    const { clientId, clientSecret, refreshToken } = oauthAuth;
+    if (!clientId || !clientSecret || !refreshToken) {
+      throw new UserError(
+        "OAuth credentials are incomplete. Run `bee auth login -m oauth` to re-authenticate."
+      );
+    }
+    refreshPromise = (async () => {
+      try {
+        consola.start("Access token expired. Refreshing...");
+        const tokenResponse = await refreshAccessToken(host, {
+          clientId,
+          clientSecret,
+          refreshToken
+        });
+        currentClient = new Backlog({
+          host,
+          accessToken: tokenResponse.access_token
+        });
+        updateSpaceAuth(host, {
+          method: "oauth",
+          accessToken: tokenResponse.access_token,
+          refreshToken: tokenResponse.refresh_token,
+          clientId,
+          clientSecret
+        });
+        consola.success("Token refreshed successfully.");
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+    const result = await refreshPromise;
+    refreshPromise = null;
+    if (!result) {
+      throw new UserError(
+        "OAuth session has expired. Run `bee auth login -m oauth` to re-authenticate."
+      );
+    }
+  };
+  const proxy = new Proxy(currentClient, {
+    get(_target, prop, receiver) {
+      const value = Reflect.get(currentClient, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return async (...args) => {
+        try {
+          return await value.apply(currentClient, args);
+        } catch (error) {
+          handleRateLimitError(error);
+          if (isBacklogAuthError(error)) {
+            await refreshTokenIfNeeded();
+            const retryValue = Reflect.get(currentClient, prop, receiver);
+            return await retryValue.apply(currentClient, args);
+          }
+          throw error;
+        }
+      };
+    }
+  });
+  return proxy;
+};
+const isBacklogAuthError = (error) => error instanceof Error && error._name === "BacklogAuthError" && error._status === 401;
+const isBacklogRateLimitError = (error) => error instanceof Error && error._name === "BacklogApiError" && error._status === 429;
+const handleRateLimitError = (error) => {
+  if (isBacklogRateLimitError(error)) {
+    const resetEpoch = error._response.headers.get("X-RateLimit-Reset");
+    const resetMessage = resetEpoch ? `Rate limit resets at ${formatResetTime(Number(resetEpoch))}.` : "Please wait and try again later.";
+    throw new UserError(`API rate limit exceeded. ${resetMessage}`);
+  }
+};
+
+export { getClient as g };

package/dist/shared/bee.ChBdZ0cH.mjs

@@ -0,0 +1,9 @@
+const resolveUserId = async (client, value) => {
+  if (value === "@me") {
+    const me = await client.getMyself();
+    return me.id;
+  }
+  return Number(value);
+};
+
+export { resolveUserId as r };

package/dist/shared/bee.CktwmH8R.mjs

@@ -0,0 +1,25 @@
+import { OAuth2 } from 'backlog-js';
+
+const exchangeAuthorizationCode = async (host, params) => {
+  const oauth2 = new OAuth2({
+    clientId: params.clientId,
+    clientSecret: params.clientSecret
+  });
+  return oauth2.getAccessToken({
+    host,
+    code: params.code,
+    redirectUri: params.redirectUri
+  });
+};
+const refreshAccessToken = async (host, params) => {
+  const oauth2 = new OAuth2({
+    clientId: params.clientId,
+    clientSecret: params.clientSecret
+  });
+  return oauth2.refreshAccessToken({
+    host,
+    refreshToken: params.refreshToken
+  });
+};
+
+export { exchangeAuthorizationCode as e, refreshAccessToken as r };

package/dist/shared/bee.CzKcWSES.mjs

@@ -0,0 +1,42 @@
+import open from 'open';
+
+const openUrl = async (url) => {
+  await open(url);
+};
+const buildBacklogUrl = (host, path) => `https://${host}${path}`;
+const issueUrl = (host, issueKey) => buildBacklogUrl(host, `/view/${issueKey}`);
+const projectUrl = (host, projectKey) => buildBacklogUrl(host, `/projects/${projectKey}`);
+const pullRequestUrl = (host, projectKey, repoName, prNumber) => buildBacklogUrl(host, `/git/${projectKey}/${repoName}/pullRequests/${prNumber}`);
+const repositoryUrl = (host, projectKey, repoName) => buildBacklogUrl(host, `/git/${projectKey}/${repoName}`);
+const wikiUrl = (host, wikiId) => buildBacklogUrl(host, `/alias/wiki/${wikiId}`);
+const documentUrl = (host, projectKey, documentId) => buildBacklogUrl(host, `/document/${projectKey}/${documentId}`);
+const categoryUrl = (host, categoryId, projectId) => buildBacklogUrl(
+  host,
+  `/EditComponent.action?component.id=${categoryId}&component.projectId=${projectId}`
+);
+const milestoneUrl = (host, milestoneId) => buildBacklogUrl(host, `/EditVersion.action?version.id=${milestoneId}`);
+const issueTypeUrl = (host, issueTypeId, projectId) => buildBacklogUrl(
+  host,
+  `/EditIssueType.action?issueType.id=${issueTypeId}&issueType.projectId=${projectId}`
+);
+const statusUrl = (host, projectKey, statusId) => buildBacklogUrl(host, `/projects/${projectKey}/statuses/${statusId}`);
+const dashboardUrl = (host) => buildBacklogUrl(host, "/dashboard");
+const gitBlobUrl = (host, projectKey, repoName, branch, filePath, line) => {
+  const url = buildBacklogUrl(host, `/git/${projectKey}/${repoName}/blob/${branch}/${filePath}`);
+  return line ? `${url}#${line}` : url;
+};
+const gitTreeUrl = (host, projectKey, repoName, branch, dirPath) => {
+  const base = `/git/${projectKey}/${repoName}/tree/${branch}`;
+  return buildBacklogUrl(host, dirPath ? `${base}/${dirPath}` : base);
+};
+const gitCommitUrl = (host, projectKey, repoName, commitSha) => buildBacklogUrl(host, `/git/${projectKey}/${repoName}/commit/${commitSha}`);
+const openOrPrintUrl = async (url, noBrowser, log) => {
+  if (noBrowser) {
+    log.log(url);
+    return;
+  }
+  await openUrl(url);
+  log.info(`Opening ${url} in your browser.`);
+};
+
+export { gitTreeUrl as a, buildBacklogUrl as b, gitBlobUrl as c, dashboardUrl as d, openUrl as e, documentUrl as f, gitCommitUrl as g, pullRequestUrl as h, issueUrl as i, categoryUrl as j, issueTypeUrl as k, milestoneUrl as m, openOrPrintUrl as o, projectUrl as p, repositoryUrl as r, statusUrl as s, wikiUrl as w };

package/dist/shared/bee.D6yQ6Pqf.mjs

@@ -0,0 +1,18 @@
+import consola from 'consola';
+import { s as stringWidth, w as widthPadEnd } from './bee.Ds2l-nTJ.mjs';
+
+const printDefinitionList = (items, indent = 4) => {
+  const filtered = items.filter(
+    (item) => item[1] !== null && item[1] !== void 0 && item[1] !== ""
+  );
+  if (filtered.length === 0) {
+    return;
+  }
+  const maxLabel = Math.max(...filtered.map(([label]) => stringWidth(label)));
+  const pad = " ".repeat(indent);
+  for (const [label, value] of filtered) {
+    consola.log(`${pad}${widthPadEnd(label, maxLabel)}  ${value}`);
+  }
+};
+
+export { printDefinitionList as p };

package/dist/shared/bee.DHTPkjMh.mjs

@@ -0,0 +1,48 @@
+import { Option } from 'commander';
+import { p as promptRequired } from './bee.DVTuFf-T.mjs';
+import 'node:stream/consumers';
+import 'valibot';
+import 'consola';
+
+class RequiredOption extends Option {
+  promptLabel;
+  constructor(flags, description, promptLabel) {
+    super(flags, `${description} (required)`);
+    this.promptLabel = promptLabel ?? description;
+  }
+}
+const resolveOptions = async (cmd) => {
+  const opts = cmd.opts();
+  for (const opt of cmd.options) {
+    if (opt instanceof RequiredOption) {
+      const key = opt.attributeName();
+      opts[key] = await promptRequired(`${opt.promptLabel}:`, opts[key]);
+    }
+  }
+};
+
+const collect = (val, prev) => [...prev, val];
+const collectNum = (val, prev) => [...prev, Number(val)];
+const project = () => new RequiredOption("-p, --project <id>", "Project ID or project key").env("BACKLOG_PROJECT");
+const repo = () => new RequiredOption("-R, --repo <name>", "Repository name or ID").env("BACKLOG_REPO");
+const count = () => new Option("-L, --count <n>", "Number of results (default: 20)");
+const offset = () => new Option("--offset <n>", "Offset for pagination");
+const order = () => new Option("--order <dir>", "Sort order").choices(["asc", "desc"]);
+const minId = () => new Option("--min-id <n>", "Minimum ID for cursor-based pagination");
+const maxId = () => new Option("--max-id <n>", "Maximum ID for cursor-based pagination");
+const keyword = () => new Option("-k, --keyword <text>", "Keyword search");
+const assignee = () => new Option("-a, --assignee <id>", "Assignee user ID. Use @me for yourself.");
+const assigneeList = () => new Option("-a, --assignee <id>", "Assignee user ID (repeatable). Use @me for yourself.").argParser(collect).default([]);
+const issue = () => new Option("--issue <key>", "Issue ID or issue key");
+const notify = () => new Option("--notify <id>", "User IDs to notify (repeatable)").argParser(collectNum).default([]);
+const attachment = () => new Option("--attachment <id>", "Attachment IDs (repeatable)").argParser(collectNum).default([]);
+const comment = () => new Option("-c, --comment <text>", "Comment to add with the update");
+const web = (resource) => new Option("-w, --web", `Open the ${resource} in the browser`);
+const noBrowser = () => new Option("-n, --no-browser", "Print the URL instead of opening the browser");
+const space = () => new Option("-s, --space <hostname>", "Space hostname").env("BACKLOG_SPACE");
+const json = () => new Option(
+  "--json [fields]",
+  "Output as JSON (optionally filter by field names, comma-separated)"
+).preset("");
+
+export { RequiredOption as R, collectNum as a, count as b, collect as c, assigneeList as d, offset as e, assignee as f, notify as g, attachment as h, comment as i, json as j, keyword as k, maxId as l, minId as m, noBrowser as n, order as o, project as p, repo as q, resolveOptions as r, space as s, issue as t, web as w };

package/dist/shared/bee.DVTuFf-T.mjs

@@ -0,0 +1,276 @@
+import consola from 'consola';
+import { U as UserError } from './bee.XxOB1Her.mjs';
+import 'node:stream/consumers';
+import * as v from 'valibot';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { R as RcSchema } from './bee.BeQSH2t0.mjs';
+
+const promptRequired = async (label, existing, options) => {
+  if (existing !== void 0) {
+    if (existing) {
+      return existing;
+    }
+    throw new UserError(`${label.replace(/:$/, "")} is required.`);
+  }
+  if (!process.stdin.isTTY) {
+    throw new UserError(
+      `${label.replace(/:$/, "")} is required. Use arguments to provide it in non-interactive mode.`
+    );
+  }
+  const displayLabel = options?.valueHint ? label.replace(/:$/, ` ${options.valueHint}:`) : label;
+  const { valueHint: _, ...promptOptions } = options ?? {};
+  const value = await consola.prompt(displayLabel, { type: "text", ...promptOptions });
+  if (typeof value !== "string" || !value) {
+    throw new UserError(`${label.replace(/:$/, "")} is required.`);
+  }
+  return value;
+};
+const confirmOrExit = async (message, skipConfirm) => {
+  if (skipConfirm) {
+    return true;
+  }
+  if (!process.stdin.isTTY) {
+    throw new UserError("Confirmation required. Use --yes to skip in non-interactive mode.");
+  }
+  const confirmed = await consola.prompt(message, { type: "confirm" });
+  if (!confirmed) {
+    consola.info("Cancelled.");
+    return false;
+  }
+  return true;
+};
+
+//#region node_modules/.pnpm/flat@6.0.1/node_modules/flat/index.js
+function isBuffer(obj) {
+	return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+function keyIdentity(key) {
+	return key;
+}
+function flatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const maxDepth = opts.maxDepth;
+	const transformKey = opts.transformKey || keyIdentity;
+	const output = {};
+	function step(object, prev, currentDepth) {
+		currentDepth = currentDepth || 1;
+		Object.keys(object).forEach(function(key) {
+			const value = object[key];
+			const isarray = opts.safe && Array.isArray(value);
+			const type = Object.prototype.toString.call(value);
+			const isbuffer = isBuffer(value);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+			if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+			output[newKey] = value;
+		});
+	}
+	step(target);
+	return output;
+}
+function unflatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const overwrite = opts.overwrite || false;
+	const transformKey = opts.transformKey || keyIdentity;
+	const result = {};
+	if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") return target;
+	function getkey(key) {
+		const parsedKey = Number(key);
+		return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+	}
+	function addKeys(keyPrefix, recipient, target) {
+		return Object.keys(target).reduce(function(result, key) {
+			result[keyPrefix + delimiter + key] = target[key];
+			return result;
+		}, recipient);
+	}
+	function isEmpty(val) {
+		const type = Object.prototype.toString.call(val);
+		const isArray = type === "[object Array]";
+		const isObject = type === "[object Object]";
+		if (!val) return true;
+		else if (isArray) return !val.length;
+		else if (isObject) return !Object.keys(val).length;
+	}
+	target = Object.keys(target).reduce(function(result, key) {
+		const type = Object.prototype.toString.call(target[key]);
+		if (!(type === "[object Object]" || type === "[object Array]") || isEmpty(target[key])) {
+			result[key] = target[key];
+			return result;
+		} else return addKeys(key, result, flatten(target[key], opts));
+	}, {});
+	Object.keys(target).forEach(function(key) {
+		const split = key.split(delimiter).map(transformKey);
+		let key1 = getkey(split.shift());
+		let key2 = getkey(split[0]);
+		let recipient = result;
+		while (key2 !== void 0) {
+			if (key1 === "__proto__") return;
+			const type = Object.prototype.toString.call(recipient[key1]);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") return;
+			if (overwrite && !isobject || !overwrite && recipient[key1] == null) recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+			recipient = recipient[key1];
+			if (split.length > 0) {
+				key1 = getkey(split.shift());
+				key2 = getkey(split[0]);
+			}
+		}
+		recipient[key1] = unflatten(target[key], opts);
+	});
+	return result;
+}
+
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
+  }
+  return value;
+}
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
+    return value.slice(1, -1);
+  }
+  const _value = value.trim();
+  if (_value.length <= 9) {
+    switch (_value.toLowerCase()) {
+      case "true": {
+        return true;
+      }
+      case "false": {
+        return false;
+      }
+      case "undefined": {
+        return void 0;
+      }
+      case "null": {
+        return null;
+      }
+      case "nan": {
+        return Number.NaN;
+      }
+      case "infinity": {
+        return Number.POSITIVE_INFINITY;
+      }
+      case "-infinity": {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+
+//#region src/index.ts
+const RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
+const RE_LINES = /\n|\r|\r\n/;
+const defaults = {
+	name: ".conf",
+	dir: process.cwd(),
+	flat: false
+};
+function withDefaults(options) {
+	if (typeof options === "string") options = { name: options };
+	return {
+		...defaults,
+		...options
+	};
+}
+function parse(contents, options = {}) {
+	const config = {};
+	const lines = contents.split(RE_LINES);
+	for (const line of lines) {
+		const match = line.match(RE_KEY_VAL);
+		if (!match) continue;
+		const key = match[1];
+		if (!key || key === "__proto__" || key === "constructor") continue;
+		const value = destr((match[2] || "").trim());
+		if (key.endsWith("[]")) {
+			const nkey = key.slice(0, Math.max(0, key.length - 2));
+			config[nkey] = (config[nkey] || []).concat(value);
+			continue;
+		}
+		config[key] = value;
+	}
+	return options.flat ? config : unflatten(config, { overwrite: true });
+}
+function parseFile(path, options) {
+	if (!existsSync(path)) return {};
+	return parse(readFileSync(path, "utf8"), options);
+}
+function read(options) {
+	options = withDefaults(options);
+	return parseFile(resolve(options.dir, options.name), options);
+}
+function readUser(options) {
+	options = withDefaults(options);
+	options.dir = process.env.XDG_CONFIG_HOME || homedir();
+	return read(options);
+}
+function serialize(config) {
+	return Object.entries(flatten(config)).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
+}
+function write(config, options) {
+	options = withDefaults(options);
+	writeFileSync(resolve(options.dir, options.name), serialize(config), { encoding: "utf8" });
+}
+function writeUser(config, options) {
+	options = withDefaults(options);
+	options.dir = process.env.XDG_CONFIG_HOME || homedir();
+	write(config, options);
+}
+
+const CONFIG_FILE_NAME = ".beerc";
+const loadConfig = () => {
+  const raw = readUser(CONFIG_FILE_NAME);
+  const result = v.safeParse(RcSchema, raw);
+  if (!result.success) {
+    const details = result.issues.map((issue) => issue.message).join("\n");
+    throw new UserError(`Configuration Error:
+${details}`);
+  }
+  return result.output;
+};
+const writeConfig = (config) => {
+  writeUser(config, CONFIG_FILE_NAME);
+};
+const updateConfig = (updater) => {
+  const config = loadConfig();
+  const updated = updater(config);
+  writeConfig(updated);
+  return updated;
+};
+
+export { confirmOrExit as c, loadConfig as l, promptRequired as p, updateConfig as u, writeConfig as w };

package/dist/shared/bee.DoTvz3uW.mjs

@@ -0,0 +1,13 @@
+const PrStatusId = {
+  Open: 1,
+  Closed: 2,
+  Merged: 3
+};
+const PrStatusName = {
+  open: PrStatusId.Open,
+  closed: PrStatusId.Closed,
+  merged: PrStatusId.Merged
+};
+const PR_STATUS_NAMES = Object.keys(PrStatusName);
+
+export { PrStatusName as P, PR_STATUS_NAMES as a, PrStatusId as b };