@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/chunk-FKZ5E4JD.js

@@ -0,0 +1,97 @@
+import {
+  issue_sample_gate
+} from "./chunk-CQUZ6TNQ.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/issue/issue-not-before.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var PREFIX = issue_body_keys.prefix("not_before");
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u;
+var ISO_TAIL = ":00.000Z";
+var EXAMPLE = `${PREFIX} 2099-01-01T09:00Z`;
+var MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
+${EXAMPLE}`;
+var MAX_WAIT_DAYS = 7;
+var DAY_MS = 864e5;
+var MAX_WAIT_MS = MAX_WAIT_DAYS * DAY_MS;
+var MINUTES_LENGTH = 16;
+var TOO_LATE = `\`${PREFIX}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
+var BOTH = `a measurement follow-up declares one of \`${PREFIX}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
+var HEADING_MARKS = /^#{1,6}\s+/u;
+var STRAY_HEADINGS = [
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX} YYYY-MM-DDTHH:MMZ` },
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", declaration: issue_sample_gate.DECLARATION }
+];
+function declared_value(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  const line = markdown_section.unfenced_lines(background).map((text) => text.trim()).find((text) => text.startsWith(PREFIX));
+  return line?.slice(PREFIX.length).trim();
+}
+function is_valid(value) {
+  if (!DATE_PATTERN.test(value)) return false;
+  const time = Date.parse(value);
+  return !Number.isNaN(time) && new Date(time).toISOString() === `${value.slice(0, -1)}${ISO_TAIL}`;
+}
+function date_of(body = "") {
+  const value = declared_value(body);
+  return value !== void 0 && is_valid(value) ? value : void 0;
+}
+function is_date_due(body, now) {
+  const date = date_of(body);
+  return date === void 0 || Date.parse(date) <= now;
+}
+function is_due(body, now = Date.now()) {
+  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0;
+}
+function waiting_ms(body, now = Date.now()) {
+  if (is_date_due(body, now)) return void 0;
+  return Date.parse(String(date_of(body)));
+}
+function waiting_date(body, now = Date.now()) {
+  return is_date_due(body, now) ? void 0 : date_of(body);
+}
+function waiting_reason(body, now = Date.now()) {
+  const date = waiting_date(body, now);
+  if (date !== void 0) return `not before ${date}`;
+  const wait = issue_sample_gate.wait_of(body);
+  return wait === void 0 ? void 0 : issue_sample_gate.reason_of(wait);
+}
+function stray_heading_problems(body) {
+  const headings = markdown_section.unfenced_lines(body).map((line) => line.trim()).filter((line) => HEADING_MARKS.test(line)).map((line) => line.replace(HEADING_MARKS, ""));
+  return STRAY_HEADINGS.filter(({ name }) => headings.some((text) => text.startsWith(name))).map(
+    ({ name, declaration }) => `heading \`${name}\` is not read \u2014 declare it under \`${BACKGROUND_HEADING}\` as \`${declaration}\``
+  );
+}
+function latest_date(now) {
+  return `${new Date(now + MAX_WAIT_MS).toISOString().slice(0, MINUTES_LENGTH)}Z`;
+}
+function measurement_wait_problems(body, now) {
+  const date = date_of(body);
+  if (date === void 0 || !measure_declaration.is_stated(body)) return [];
+  if (issue_sample_gate.cited_number(body) !== void 0) return [BOTH];
+  return Date.parse(date) > now + MAX_WAIT_MS ? [`${TOO_LATE}
+${PREFIX} ${latest_date(now)}`] : [];
+}
+function problems(body, now = Date.now()) {
+  const value = declared_value(body);
+  const date_problems = value === void 0 || is_valid(value) ? [] : [MALFORMED];
+  return [
+    ...stray_heading_problems(body),
+    ...date_problems,
+    ...measurement_wait_problems(body, now),
+    ...issue_sample_gate.problems(body)
+  ];
+}
+var issue_not_before = { is_due, problems, waiting_date, waiting_ms, waiting_reason };
+
+export {
+  issue_not_before
+};

package/dist/commands/chunk-FMZWRDKH.js

@@ -0,0 +1,302 @@
+import {
+  epic_index
+} from "./chunk-7MJYLUF4.js";
+import {
+  issue_not_before
+} from "./chunk-FKZ5E4JD.js";
+import {
+  issue_sample_prime
+} from "./chunk-QDFVVRQP.js";
+import {
+  epic_issue
+} from "./chunk-IAD4WLLI.js";
+import {
+  git_next_issues
+} from "./chunk-HH3CVIFU.js";
+import {
+  cutoff_cause,
+  cutoff_of
+} from "./chunk-OL6IF4JC.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  SUMMARY_FIELDS,
+  git_gh_command
+} from "./chunk-YGFOGA7C.js";
+import {
+  gh_author_association
+} from "./chunk-XXNEY4B3.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-XDF25GSU.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 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-FOKCRIAN.js

@@ -0,0 +1,67 @@
+import {
+  REPOSITORY_LABELS
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_exec
+} from "./chunk-XDF25GSU.js";
+
+// scripts/repo/repository-labels.ts
+function labels_endpoint(repo) {
+  return `repos/${repo}/labels`;
+}
+function request(api) {
+  try {
+    return git_gh_exec.exec_gh_api_sync(api);
+  } catch {
+    return void 0;
+  }
+}
+function read_existing(repo) {
+  const path = labels_endpoint(repo);
+  const listing = request({ path, should_paginate: true, jq_filter: ".[].name" });
+  return listing?.split("\n").filter((name) => name.length > 0);
+}
+function missing_labels(existing, wanted) {
+  const names = new Set(existing.map((name) => name.toLowerCase()));
+  return wanted.filter((label) => !names.has(label.name.toLowerCase()));
+}
+function create_label(label, repo) {
+  const body = JSON.stringify(label);
+  const is_created = request({ path: labels_endpoint(repo), method: "POST", body }) !== void 0;
+  if (is_created) console.info(`  \u2714 label ${label.name}`);
+  return is_created;
+}
+function label_names(labels) {
+  return labels.map((label) => label.name);
+}
+function unreadable(wanted, target = "this repository") {
+  const names = label_names(wanted);
+  console.warn(
+    `  \u26A0 could not read the labels of ${target}; make sure these exist: ${names.join(", ")}`
+  );
+  return names;
+}
+function create_missing(missing, repo) {
+  const names = label_names(missing.filter((label) => !create_label(label, repo)));
+  if (names.length > 0) {
+    console.warn(`  \u26A0 could not create these labels; create them by hand: ${names.join(", ")}`);
+  }
+  return names;
+}
+function ensure_labels(repo, extra = []) {
+  const wanted = [...REPOSITORY_LABELS, ...extra];
+  if (repo === void 0) return unreadable(wanted);
+  const existing = read_existing(repo);
+  if (existing === void 0) return unreadable(wanted, repo);
+  return create_missing(missing_labels(existing, wanted), repo);
+}
+function planned_labels(repo) {
+  if (repo === void 0) return label_names(REPOSITORY_LABELS);
+  const existing = read_existing(repo);
+  return existing === void 0 ? void 0 : label_names(missing_labels(existing, REPOSITORY_LABELS));
+}
+var repository_labels = { ensure_labels, planned_labels };
+
+export {
+  repository_labels
+};

package/dist/commands/chunk-FQGWO2ZH.js

@@ -0,0 +1,43 @@
+import {
+  format_dependency_links
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-YGFOGA7C.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-relations.ts
+async function apply_one(link, action) {
+  const blocked = String(link.blocked);
+  const blocker = String(link.blocker);
+  return action === "record" ? await git_gh_command.issue_add_blocked_by(blocked, blocker) : await git_gh_command.issue_remove_blocked_by(blocked, blocker);
+}
+async function apply_relations(links, action) {
+  if (links.length === 0) return 0;
+  const applied = await Promise.all(links.map(async (link) => await apply_one(link, action)));
+  return applied.filter((is_applied) => !is_applied).length;
+}
+function describe_action(action) {
+  return action === "record" ? "recorded" : "removed";
+}
+function format_relation_report(input) {
+  const verb = describe_action(input.action);
+  const total = String(input.links.length);
+  if (input.links.length === 0) return `\u{1F517} No blocked-by relation was ${verb}.`;
+  if (input.failures === 0) {
+    return session_cite.text(
+      `\u{1F517} ${total} blocked-by relation(s) ${verb}: ${format_dependency_links(input.links)}.`
+    );
+  }
+  return `\u26A0\uFE0F  ${String(input.failures)} of ${total} blocked-by relation(s) could not be ${verb}; the epic body is intact.`;
+}
+var epic_relations = {
+  apply_relations,
+  format_relation_report
+};
+
+export {
+  epic_relations
+};