@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-RFIOZTXY.js

@@ -0,0 +1,305 @@
+import {
+  epic_index
+} from "./chunk-NHTEC5U4.js";
+import {
+  issue_publication_state
+} from "./chunk-G2DNS74C.js";
+import {
+  issue_not_before
+} from "./chunk-PCZROH3R.js";
+import {
+  issue_sample_prime
+} from "./chunk-WWLCQREY.js";
+import {
+  epic_issue
+} from "./chunk-YEAE46TS.js";
+import {
+  git_next_issues
+} from "./chunk-SRTEE34O.js";
+import {
+  cutoff_cause,
+  cutoff_of
+} from "./chunk-DACNQAXC.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  SUMMARY_FIELDS,
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  gh_author_association
+} from "./chunk-5YTEMF4O.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  AUTO_OK_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  read_json_listing
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/auto-ok/auto-ok-author.ts
+function shared_author_of(row) {
+  return { ...gh_author_association.author_of(row), is_shared: true };
+}
+async function with_trust(issue) {
+  const author = shared_author_of(issue);
+  return { ...issue, author_trusted: await gh_author_association.is_trusted(author) };
+}
+async function with_author_trust(issues) {
+  return await Promise.all(issues.map(async (issue) => await with_trust(issue)));
+}
+function is_author_trusted(issue) {
+  return issue.author_trusted === true;
+}
+async function is_child_trusted(child, repo) {
+  const author = shared_author_of(child);
+  return await gh_author_association.is_trusted(
+    child.repo === repo ? author : { ...author, login: void 0 }
+  );
+}
+async function untrusted_child_keys(children, repo) {
+  const open = children.filter((child) => child.state === "OPEN");
+  const trusted = await Promise.all(open.map(async (child) => await is_child_trusted(child, repo)));
+  const untrusted = open.filter((_, index) => trusted[index] !== true);
+  return new Set(untrusted.map((child) => epic_graph.key_of(child)));
+}
+var auto_ok_author = { is_author_trusted, untrusted_child_keys, with_author_trust };
+
+// scripts/epic/epic-bundle-gaps.ts
+function backlog_gap(cutoff, limit) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(limit)}-issue cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0 The backlog listing ${cause}; older issues were not considered.`;
+}
+function epic_gap(cutoff, limit) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(limit)}-epic cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0 The epic listing ${cause}; an epic past it was not considered.`;
+}
+function is_membership_established(cutoff = "none") {
+  return cutoff === "none";
+}
+var UNCONFIRMED_MEMBERSHIP_LINE = "Could not confirm which epic already tracks these \u2014 do not place this issue in one.";
+var UNCONFIRMED_MEMBERSHIP_REASON = "the epics were not read in full, so an epic already tracking one of these may never have been seen";
+function unconfirmed_membership(related) {
+  return [
+    UNCONFIRMED_MEMBERSHIP_LINE,
+    `  ${UNCONFIRMED_MEMBERSHIP_REASON}`,
+    `  Related: ${related}`
+  ];
+}
+var epic_bundle_gaps = {
+  backlog_gap,
+  epic_gap,
+  is_membership_established,
+  UNCONFIRMED_MEMBERSHIP_LINE,
+  unconfirmed_membership
+};
+
+// scripts/auto-ok/auto-ok-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var EXCLUDE_FLAG = "--exclude";
+var EXCLUDE_SEPARATOR = ",";
+var EXCLUDE_PAIR_SIZE = 2;
+var USAGE = `Usage: josh auto-ok:next [${EXCLUDE_FLAG} <issue-number>[,<issue-number>...]]...`;
+var NONE_TOKEN = "none";
+var LISTING_LIMIT = 200;
+var UNREADABLE_MESSAGE = `Could not read the \`${AUTO_OK_LABEL}\` listing. That is not "nothing is opted in" \u2014 check \`gh auth status\` and ask again.`;
+var UNEXPECTED_SHAPE_MESSAGE = `Read the \`${AUTO_OK_LABEL}\` listing but could not parse it. That is not "nothing is opted in" \u2014 the rows came back in a shape this command does not recognize, so check the fields it asks for and the REST field mapping in \`scripts/gh/git-gh-issue-rest.ts\` rather than your authentication.`;
+var BLOCKERS_UNREADABLE_MESSAGE = `Could not read the \`${AUTO_OK_LABEL}\` listing, though the same listing reads once the blocker relations are dropped from it \u2014 so it is reading the relations that failed, not your authentication. That is one \`dependencies/blocked_by\` request per opted-in issue declaring a blocker: either this GitHub host does not serve issue dependencies, or those requests are being rate limited. Ask again, and check the host if it persists.`;
+var TRUNCATED_BY_LIMIT = `hit the ${String(LISTING_LIMIT)}-issue cap`;
+var TRUNCATED_WITH_ANSWER = "; the answer below is opted in, but it may not be the highest-priority one.";
+var TRUNCATED_WITHOUT_ANSWER = ", and every issue in it was excluded \u2014 an opted-in issue older than the cut may still be runnable.";
+function truncated_cause(cutoff) {
+  return cutoff_cause(cutoff, TRUNCATED_BY_LIMIT);
+}
+var NONE_OPTED_IN_MESSAGE = `No open issue carries \`${AUTO_OK_LABEL}\`.`;
+var EPICS_UNREADABLE_MESSAGE = `Could not read the epic listing, so which issues an epic already tracks is unknown. That is not "no epic tracks anything" \u2014 an opted-in child would be handed back outside its epic's order, so no answer is given. Check \`gh auth status\` and ask again.`;
+var CLOSED_STATE = "CLOSED";
+var NO_CUTOFF = "none";
+function parse_issue_number(value) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
+function parse_exclude(value) {
+  if (value === void 0) return void 0;
+  const parsed = value.split(EXCLUDE_SEPARATOR).map((entry) => parse_issue_number(entry.trim()));
+  return parsed.every((entry) => entry !== void 0) ? parsed : void 0;
+}
+function parse_pair(argv, index) {
+  if (argv[index] !== EXCLUDE_FLAG) return void 0;
+  return parse_exclude(argv[index + 1]);
+}
+function parse_options(argv, usage = USAGE) {
+  const exclude = [];
+  for (let index = 0; index < argv.length; index += EXCLUDE_PAIR_SIZE) {
+    const parsed = parse_pair(argv, index);
+    if (parsed === void 0) return { usage };
+    exclude.push(...parsed);
+  }
+  return exclude.length === 0 ? {} : { exclude };
+}
+function parse_listing(raw, is_capped) {
+  const read = read_json_listing(raw, open_issue_schema);
+  if (read.kind !== "read") return { kind: read.kind };
+  return {
+    kind: "read",
+    issues: read.rows,
+    cutoff: cutoff_of(read.rows.length, LISTING_LIMIT, is_capped)
+  };
+}
+async function reads_without_blocked_by() {
+  const probe = await git_gh_command.issue_list_by_label_summary(AUTO_OK_LABEL, LISTING_LIMIT, {
+    json_fields: SUMMARY_FIELDS
+  });
+  return probe.json !== void 0;
+}
+async function classify_failed_read() {
+  if (!await reads_without_blocked_by()) return { kind: "unreadable" };
+  const retry = await git_gh_command.issue_list_by_label_summary(AUTO_OK_LABEL, LISTING_LIMIT);
+  return retry.json === void 0 ? { kind: "blockers_unreadable" } : parse_listing(retry.json, retry.is_capped);
+}
+async function fetch_opted_in() {
+  const { json, is_capped, is_unchanged } = await git_gh_command.issue_list_by_label_summary(
+    AUTO_OK_LABEL,
+    LISTING_LIMIT
+  );
+  const read = json === void 0 ? await classify_failed_read() : parse_listing(json, is_capped);
+  if (read.kind !== "read") return read;
+  const issues = await auto_ok_author.with_author_trust(read.issues);
+  await issue_sample_prime.prime(issues.map((issue) => issue.body));
+  return { ...read, issues, is_unchanged: is_unchanged === true };
+}
+function is_page_complete(blocked_by) {
+  const nodes = blocked_by?.nodes ?? [];
+  return (blocked_by?.totalCount ?? nodes.length) <= nodes.length;
+}
+function is_closed(blocker) {
+  return epic_issue.normalize_state(blocker.state ?? "") === CLOSED_STATE;
+}
+function is_unblocked(issue) {
+  if (!is_page_complete(issue.blockedBy)) return false;
+  return (issue.blockedBy?.nodes ?? []).every((blocker) => is_closed(blocker));
+}
+async function read_open_epics() {
+  try {
+    return await epic_index.fetch_epics(LISTING_LIMIT);
+  } catch {
+    return void 0;
+  }
+}
+async function fetch_tracking(count) {
+  if (count === 0) return { kind: "read", index: /* @__PURE__ */ new Map(), cutoff: NO_CUTOFF };
+  const open_epics = await read_open_epics();
+  if (open_epics === void 0) return { kind: "epics_unreadable" };
+  return {
+    kind: "read",
+    index: epic_index.build_tracking_index(open_epics.epics),
+    cutoff: open_epics.cutoff
+  };
+}
+function is_ready(issue, options) {
+  return !issue_publication_state.is_pending(issue.body) && auto_ok_author.is_author_trusted(issue) && is_unblocked(issue) && issue_not_before.is_due(issue.body, options.now ?? Date.now());
+}
+function is_runnable(issue, tracked, exclude, options = {}) {
+  if (tracked.has(issue.number)) return false;
+  return !exclude.includes(issue.number) && is_ready(issue, options);
+}
+function pick_next(issues, tracked = /* @__PURE__ */ new Map(), exclude = [], options = {}) {
+  return git_next_issues.order(issues).find((issue) => is_runnable(issue, tracked, exclude, options));
+}
+function none_reason(count) {
+  if (count === 0) return NONE_OPTED_IN_MESSAGE;
+  return `All ${String(count)} open \`${AUTO_OK_LABEL}\` issue(s) are excluded \u2014 tracked by an opted-in epic, an epic itself, already in progress, parked, filed by an author without write access (waiting on a person), blocked by an open issue, not due until its start time, or the one just merged.`;
+}
+function truncation_note(cutoff, has_answer) {
+  const cause = truncated_cause(cutoff);
+  if (cause === void 0) return void 0;
+  const tail = has_answer ? TRUNCATED_WITH_ANSWER : TRUNCATED_WITHOUT_ANSWER;
+  return `\u26A0 The listing ${cause}, so the oldest \`${AUTO_OK_LABEL}\` issues are not in it${tail}`;
+}
+function warn_gaps(context, has_answer) {
+  const note = truncation_note(context.cutoff, has_answer);
+  if (note !== void 0) console.error(note);
+  const epic_note = epic_bundle_gaps.epic_gap(context.epic_cutoff, LISTING_LIMIT);
+  if (epic_note !== void 0) console.error(epic_note);
+}
+function report(context) {
+  const { issues } = context;
+  const next = pick_next(issues, context.tracked, context.exclude, context);
+  warn_gaps(context, next !== void 0);
+  if (next === void 0) {
+    console.error(none_reason(issues.length));
+    console.info(NONE_TOKEN);
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(session_cite.issue(next.number, next.title));
+  console.info(String(next.number));
+  return SUCCESS_EXIT_CODE;
+}
+async function answer(read, exclude) {
+  const tracking = await fetch_tracking(read.issues.length);
+  if (tracking.kind !== "read") {
+    console.error(EPICS_UNREADABLE_MESSAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return report({
+    issues: read.issues,
+    cutoff: read.cutoff,
+    tracked: epic_index.withheld_children(tracking.index, read.issues),
+    epic_cutoff: tracking.cutoff,
+    exclude
+  });
+}
+var READ_FAILURE_MESSAGES = {
+  unreadable: UNREADABLE_MESSAGE,
+  unexpected_shape: UNEXPECTED_SHAPE_MESSAGE,
+  blockers_unreadable: BLOCKERS_UNREADABLE_MESSAGE
+};
+async function run(argv) {
+  const options = parse_options(argv);
+  if (options.usage !== void 0) {
+    console.error(options.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const read = await fetch_opted_in();
+  if (read.kind !== "read") {
+    console.error(READ_FAILURE_MESSAGES[read.kind]);
+    return FAILURE_EXIT_CODE;
+  }
+  return await answer(read, options.exclude);
+}
+var auto_ok_cli = {
+  USAGE,
+  NONE_TOKEN,
+  LISTING_LIMIT,
+  UNREADABLE_MESSAGE,
+  UNEXPECTED_SHAPE_MESSAGE,
+  BLOCKERS_UNREADABLE_MESSAGE,
+  EPICS_UNREADABLE_MESSAGE,
+  TRUNCATED_WITH_ANSWER,
+  TRUNCATED_WITHOUT_ANSWER,
+  NONE_OPTED_IN_MESSAGE,
+  truncated_cause,
+  parse_options,
+  fetch_opted_in,
+  fetch_tracking,
+  is_runnable,
+  pick_next,
+  truncation_note,
+  run
+};
+
+export {
+  auto_ok_author,
+  epic_bundle_gaps,
+  auto_ok_cli
+};

package/dist/commands/chunk-RFWB2KAV.js

@@ -0,0 +1,102 @@
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_subject_schema
+} from "./chunk-34DND4BA.js";
+import {
+  EPIC_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/epic/epic-validate.ts
+function parse_epic_subject(raw_json) {
+  if (raw_json === void 0) return void 0;
+  const parsed = parse_json_object_or_undefined(raw_json, epic_subject_schema);
+  if (parsed === void 0) return void 0;
+  return {
+    number: parsed.number,
+    state: parsed.state,
+    labels: (parsed.labels ?? []).map((label) => label.name),
+    body: parsed.body
+  };
+}
+function check_label(subject) {
+  const is_passing = has_label_name(subject.labels, EPIC_LABEL);
+  return {
+    name: "epic label",
+    is_passing,
+    detail: is_passing ? `the \`${EPIC_LABEL}\` label is applied` : `add the \`${EPIC_LABEL}\` label \u2014 the auto-close only looks at labelled issues`
+  };
+}
+function format_children(children) {
+  return children.map((child) => session_cite.issue(child)).join(", ");
+}
+function check_task_list(subject) {
+  const children = epic_parse.parse_task_list_issue_numbers(subject.body);
+  const is_passing = children.length > 0;
+  return {
+    name: "child task list",
+    is_passing,
+    detail: is_passing ? `${String(children.length)} child issue(s) tracked: ${format_children(children)}` : "no `- [ ] #N` rows found \u2014 a bare `#N` link is not tracked and never auto-closes"
+  };
+}
+function describe_dependencies(state) {
+  if (state.has_chain && state.has_none_literal) {
+    return "a chain (`#N -> #M`) and the `None \u2014 ...` literal are both declared; they contradict each other";
+  }
+  if (state.has_chain) return "an ordered chain (`#N -> #M`) is declared";
+  if (state.has_none_literal) return "declared as an unordered batch";
+  return "neither a line that is only `#N -> #M` nor the `None \u2014 ...` literal found; an arrow sharing its line with anything else is prose, and prose order is not machine-readable";
+}
+function check_dependencies(subject) {
+  const state = epic_parse.read_declaration(subject.body);
+  return {
+    name: "dependencies section",
+    is_passing: epic_parse.is_declaration_readable(state),
+    detail: describe_dependencies(state)
+  };
+}
+function check_external_children(subject) {
+  const has_external = epic_parse.has_external_task_list_entry(subject.body);
+  return {
+    name: "auto-close eligibility",
+    is_passing: !has_external,
+    detail: has_external ? "tracks a child in another repository \u2014 this epic will not auto-close; close it manually" : "every tracked child is in this repository"
+  };
+}
+function validate_epic(subject) {
+  return [
+    check_label(subject),
+    check_task_list(subject),
+    check_dependencies(subject),
+    check_external_children(subject)
+  ];
+}
+function is_epic_valid(results) {
+  return results.every((result) => result.is_passing);
+}
+function format_check_line(result) {
+  return `${result.is_passing ? "\u2714" : "\u2716"} ${result.name} \u2014 ${result.detail}`;
+}
+function format_check_report(epic_number, results) {
+  const lines = results.map((result) => format_check_line(result));
+  const summary = is_epic_valid(results) ? `\u2705 Epic ${session_cite.issue(epic_number)} satisfies every requirement.` : `\u274C Epic ${session_cite.issue(epic_number)} does not satisfy every requirement.`;
+  return [...lines, "", summary].join("\n");
+}
+var epic_validate = {
+  parse_epic_subject,
+  validate_epic,
+  is_epic_valid,
+  format_check_report
+};
+
+export {
+  epic_validate
+};

package/dist/commands/chunk-RFXON3FK.js

@@ -0,0 +1,25 @@
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+
+// scripts/run/hold/run-hold-block.ts
+function held_block(hold, issue) {
+  return run_hold.is_reentry(hold, issue) ? void 0 : run_hold.held_message(hold);
+}
+function is_own_unstopped(hold, issue) {
+  return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold);
+}
+async function stale_block(hold, issue) {
+  if (is_own_unstopped(hold, issue)) return void 0;
+  return await run_hold.is_tree_dirty() ? run_hold.uncommitted_message(hold) : void 0;
+}
+async function blocking_message(read, issue) {
+  if (read.kind === "held") return held_block(read.hold, issue);
+  if (read.kind === "unreadable") return run_hold.unreadable_message();
+  return read.kind === "stale" ? await stale_block(read.hold, issue) : void 0;
+}
+var run_hold_block = { blocking_message };
+
+export {
+  run_hold_block
+};

package/dist/commands/chunk-RGEB5L37.js

@@ -0,0 +1,66 @@
+import {
+  telegram_test
+} from "./chunk-SD4EX75H.js";
+import {
+  git_gh_repo
+} from "./chunk-CTXJVMHW.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/issue/issue-plan-notify.ts
+var CHANGE_HEADING = /^#{2,3}\s+変更\s*$/u;
+var ANY_HEADING = /^#{1,6}\s/u;
+var TOP_LEVEL_ITEM = /^(?:[-*+]|\d+\.)\s+(?<text>\S.*)$/u;
+var SUMMARY_ITEMS = 3;
+var KICKOFF = "kickoff";
+function section_body(section) {
+  const lines = markdown_section.written_fence_free_lines(section.join("\n"));
+  const end = lines.findIndex((line) => ANY_HEADING.test(line.trim()));
+  return end === -1 ? lines : lines.slice(0, end);
+}
+function summary_of(plan) {
+  const section = markdown_section.written_section_lines_matching(
+    plan,
+    (line) => CHANGE_HEADING.test(line.trim())
+  );
+  const lines = section.length === 0 ? markdown_section.written_fence_free_lines(plan) : section_body(section);
+  const items = lines.map((line) => TOP_LEVEL_ITEM.exec(line)?.groups?.["text"]);
+  return items.filter((item) => item !== void 0).slice(0, SUMMARY_ITEMS);
+}
+function body_of(notice) {
+  const items = summary_of(notice.plan).map((item) => `- ${item}`);
+  return [...items, run_stage.next_line(KICKOFF, notice.issue_number)].join("\n");
+}
+async function slug_of(repo) {
+  return repo ?? await git_gh_repo.repo_get_name_with_owner();
+}
+async function values_of(message) {
+  const slug = await slug_of(message.repo);
+  const url = slug === void 0 ? {} : { "issue-url": issue_cite.issue_url(slug, message.issue_number) };
+  const title = message.title === void 0 ? {} : { "issue-title": message.title };
+  return { "task-type": "planning", body: message.body, ...url, ...title };
+}
+async function send_planning(message) {
+  try {
+    await telegram_test.send_values(await values_of(message));
+  } catch (error) {
+    console.error(
+      `\u26A0\uFE0F  ${message.command} could not send the planning notification: ${String(error)}`
+    );
+  }
+}
+async function send(notice) {
+  await send_planning({ ...notice, body: body_of(notice), command: "issue:plan" });
+}
+var issue_plan_notify = { summary_of, send, send_planning, slug_of };
+
+export {
+  issue_plan_notify
+};

package/dist/commands/chunk-RGRLLF2J.js

@@ -0,0 +1,119 @@
+import {
+  package_with_version_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/release/release-plan.ts
+import semver from "semver";
+var PENDING_ICON = "\u{1F69A}";
+var SHORT_SHA_LENGTH = 7;
+function previous_version_of(commits, index, oldest_parent_version) {
+  const previous = commits[index + 1];
+  return previous === void 0 ? oldest_parent_version : previous.version;
+}
+function find_version_base(commits, oldest_parent_version) {
+  const found = commits.find((commit, index) => {
+    const previous = previous_version_of(commits, index, oldest_parent_version);
+    return commit.version !== void 0 && previous !== void 0 && commit.version !== previous;
+  });
+  return found?.sha;
+}
+function next_version(current, pending) {
+  const parsed = semver.parse(current);
+  if (parsed === null) throw new Error(`Invalid version format: ${current}`);
+  if (pending === 0) return parsed.version;
+  return `${String(parsed.major)}.${String(parsed.minor + pending)}.0`;
+}
+function short_sha(sha) {
+  return sha.slice(0, SHORT_SHA_LENGTH);
+}
+function format_pending_line(pending) {
+  return `${PENDING_ICON} unreleased merges on main: ${String(pending)}`;
+}
+function format_nothing_to_release(base) {
+  return [
+    format_pending_line(0),
+    `  Nothing to release \u2014 no merge has landed on main since ${short_sha(base)}, the commit that last changed the version.`
+  ].join("\n");
+}
+function format_plan(plan) {
+  return [
+    format_pending_line(plan.pending),
+    `  base ${short_sha(plan.base)} \xB7 ${plan.current_version} \u2192 ${plan.next_version}`
+  ].join("\n");
+}
+var release_plan = {
+  find_version_base,
+  previous_version_of,
+  format_nothing_to_release,
+  format_pending_line,
+  format_plan,
+  next_version,
+  short_sha
+};
+
+// scripts/release/release-history.ts
+var BASE_SEARCH_LIMIT = 30;
+var DEFAULT_TIP = "HEAD";
+var git_reader = {
+  log_first_parent: git_command.log_first_parent,
+  show_file: git_command.show_file,
+  count_merges: git_command.count_merges
+};
+function parse_version(content) {
+  if (content === void 0) return void 0;
+  return json_value.parse_with(content, package_with_version_schema)?.version;
+}
+async function read_version_at(reader, reference) {
+  try {
+    return parse_version(await reader.show_file(`${reference}:./${PACKAGE_JSON}`));
+  } catch {
+    return void 0;
+  }
+}
+async function read_versioned_commits(reader, tip) {
+  const shas = await reader.log_first_parent(BASE_SEARCH_LIMIT, PACKAGE_JSON, tip);
+  return await Promise.all(
+    shas.map(async (sha) => ({ sha, version: await read_version_at(reader, sha) }))
+  );
+}
+async function read_base(reader = git_reader, tip = DEFAULT_TIP) {
+  const commits = await read_versioned_commits(reader, tip);
+  const oldest = commits.at(-1);
+  const oldest_parent_version = oldest === void 0 ? void 0 : await read_version_at(reader, `${oldest.sha}^`);
+  return release_plan.find_version_base(commits, oldest_parent_version);
+}
+async function read_current_version(tip = DEFAULT_TIP, reader = git_reader) {
+  return await read_version_at(reader, tip);
+}
+async function read_release_plan(current_version, reader = git_reader, tip = DEFAULT_TIP) {
+  const base = await read_base(reader, tip);
+  if (base === void 0) return void 0;
+  const pending = await reader.count_merges(`${base}..${tip}`);
+  return {
+    base,
+    pending,
+    current_version,
+    next_version: release_plan.next_version(current_version, pending)
+  };
+}
+var release_history = {
+  parse_version,
+  read_base,
+  read_current_version,
+  read_release_plan,
+  BASE_SEARCH_LIMIT
+};
+
+export {
+  release_plan,
+  release_history
+};