@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-5QICRFVL.js

@@ -0,0 +1,167 @@
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  lane_reap,
+  process_tools
+} from "./chunk-VFW6XZH7.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-handoff.ts
+function is_ship_running(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  return repository !== void 0 && run_ship_detach.read_result(repository, issue)?.result === "running";
+}
+function is_ship_succeeded(issue, directory, since_ms) {
+  const repository = git_common_directory.repository(directory);
+  const reading = repository === void 0 ? void 0 : run_ship_detach.read_result(repository, issue);
+  return reading?.result === "success" && (reading.launched_at ?? since_ms - 1) >= since_ms;
+}
+async function read_repository() {
+  try {
+    return await run_carry.repository_directory();
+  } catch {
+    return void 0;
+  }
+}
+async function ship_reader(read) {
+  const repository = await read_repository();
+  return (issue) => repository !== void 0 && run_ship_detach.read_result(repository, issue, read)?.result === "running";
+}
+function is_merge_waiting(repository, issue, read) {
+  if (run_ship_detach.read_result(repository, issue, read)?.result !== "running") return false;
+  return run_ship_stage.read_merge_waiting(run_ship_stage.record_path(repository, issue));
+}
+async function merge_wait_reader(read) {
+  const repository = await read_repository();
+  return (issue) => repository !== void 0 && is_merge_waiting(repository, issue, read);
+}
+function is_place_waiting(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0 || !is_ship_running(issue, directory)) return false;
+  return run_ship_stage.read_place_waiting(run_ship_stage.record_path(repository, issue));
+}
+function ship_running_since(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  return repository === void 0 ? void 0 : run_ship_detach.running_since(repository, issue);
+}
+function is_handed_off(directory, source = process.env) {
+  const issue = lane_child_marker.marked_issue(source);
+  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
+  return is_ship_running(issue, directory);
+}
+var lane_handoff = {
+  is_handed_off,
+  is_place_waiting,
+  is_ship_running,
+  is_ship_succeeded,
+  merge_wait_reader,
+  ship_reader,
+  ship_running_since
+};
+
+// scripts/lane/lane-process-table.ts
+import { execa } from "execa";
+var COLUMNS = ["pid=", "ppid=", "time=", "rss=", "stat=", process_identity.START_TIME_FORMAT];
+var PS_ARGUMENTS = ["-A", "-ww", "-o", [...COLUMNS, "command="].join(",")];
+var PS_ENVIRONMENT = process_identity.PROBE_ENVIRONMENT;
+var FIELD_SEPARATOR = /\s+/u;
+var START_FIELDS = 5;
+var DAY_FIELD = 2;
+var DAY_WIDTH = 2;
+function is_row(row) {
+  const { pid, parent, rss_kb, command } = row;
+  return Number.isSafeInteger(pid + parent) && Number.isFinite(rss_kb) && command !== "";
+}
+function start_of(fields) {
+  return fields.map((field, index) => index === DAY_FIELD ? field.padStart(DAY_WIDTH) : field).join(" ");
+}
+function row_of(line) {
+  const [pid, parent, time = "", rss, stat = "", ...rest] = line.trim().split(FIELD_SEPARATOR);
+  const numbers = { pid: Number(pid), parent: Number(parent), rss_kb: Number(rss) };
+  const start = start_of(rest.slice(0, START_FIELDS));
+  const row = { ...numbers, time, stat, start, command: rest.slice(START_FIELDS).join(" ") };
+  return is_row(row) ? row : void 0;
+}
+function parse(printed) {
+  return printed.split("\n").map((line) => row_of(line)).filter((row) => row !== void 0);
+}
+function matching_in(rows, pattern) {
+  const expression = new RegExp(pattern, "u");
+  return rows.filter((row) => expression.test(row.command)).map((row) => row.pid);
+}
+function children_index(rows) {
+  const children = /* @__PURE__ */ new Map();
+  for (const { pid, parent } of rows) {
+    const siblings = children.get(parent) ?? [];
+    siblings.push(pid);
+    children.set(parent, siblings);
+  }
+  return children;
+}
+function probes_of(rows) {
+  const by_pid = new Map(rows.map((row) => [row.pid, row]));
+  const children = children_index(rows);
+  return {
+    matching: (pattern) => matching_in(rows, pattern),
+    children_of: (pid) => children.get(pid) ?? [],
+    parent_of: (pid) => by_pid.get(pid)?.parent
+  };
+}
+function start_reader(rows) {
+  const starts = new Map(rows.map((row) => [row.pid, row.start]));
+  const probes = {
+    ...process_identity.START_PROBES,
+    read_ps_start: (pid) => starts.get(pid)
+  };
+  return (pid) => process_identity.read_start(pid, probes);
+}
+async function read_table() {
+  try {
+    const { stdout } = await execa(lane_reap.PS_COMMAND, PS_ARGUMENTS, {
+      env: PS_ENVIRONMENT,
+      timeout: PROBE_TIMEOUT_MS
+    });
+    return parse(stdout);
+  } catch (error) {
+    process_tools.throw_if_missing(lane_reap.PS_COMMAND, error);
+    return void 0;
+  }
+}
+function shared(read) {
+  const taken = {};
+  return async function table() {
+    taken.table ??= read();
+    return await taken.table;
+  };
+}
+var lane_process_table = {
+  PS_ARGUMENTS,
+  parse,
+  probes_of,
+  read_table,
+  shared,
+  start_reader
+};
+
+export {
+  lane_process_table,
+  lane_handoff
+};

package/dist/commands/chunk-5RCBXYYD.js

@@ -0,0 +1,101 @@
+import {
+  issue_auto_ok
+} from "./chunk-N5YPDLZM.js";
+import {
+  AUTO_OK_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/issue/issue-publication-state.ts
+import { z } from "zod";
+var PREFIX = "<!-- josh:publication ";
+var RECORDS = /^<!-- josh:publication (?<record>[^\n]*?) -->/gmu;
+var RECORD_LINE = /^<!-- josh:publication /mu;
+var FENCE_LINE = /^ {0,3}(?<marker>`{3,}|~{3,})/u;
+var schema = z.object({ labels: z.array(z.string()) });
+function fence_marker(line) {
+  return FENCE_LINE.exec(line)?.groups?.["marker"];
+}
+function is_close(fence, line) {
+  const marker = fence_marker(line) ?? "";
+  const is_same = marker.startsWith(fence.marker.charAt(0));
+  return is_same && marker.length >= fence.marker.length && line.trim() === marker;
+}
+function continued(fence, line) {
+  if (is_close(fence, line)) return void 0;
+  fence.lines.push(line);
+  return fence;
+}
+function opened(kept, line) {
+  const marker = fence_marker(line);
+  if (marker === void 0) kept.push(line);
+  return marker === void 0 ? void 0 : { marker, lines: [line] };
+}
+function scan_line({ kept, fence }, line) {
+  return { kept, fence: fence === void 0 ? opened(kept, line) : continued(fence, line) };
+}
+function unfenced(body) {
+  let scan = { kept: [], fence: void 0 };
+  for (const line of body.split("\n")) scan = scan_line(scan, line);
+  return [...scan.kept, ...scan.fence?.lines ?? []].join("\n");
+}
+function is_pending(body = "") {
+  return RECORD_LINE.test(unfenced(body));
+}
+function last_record(body) {
+  return [...unfenced(body).matchAll(RECORDS)].at(-1);
+}
+function prepare(body, labels) {
+  if (is_pending(body)) throw new Error("Issue already contains a publication record");
+  return `${body}
+
+${PREFIX}${JSON.stringify({ labels })} -->
+`;
+}
+function carried(previous, next) {
+  const record = last_record(previous ?? "")?.[0];
+  if (record === void 0 || is_pending(next)) return next;
+  return `${next.trimEnd()}
+
+${record}
+`;
+}
+function public_body(body) {
+  const record = last_record(body)?.[0] ?? "";
+  const at = body.lastIndexOf(record);
+  return `${body.slice(0, at)}${body.slice(at + record.length)}`.trimEnd();
+}
+function intended_labels(body = "") {
+  const record = last_record(body)?.groups?.["record"];
+  return schema.parse(JSON.parse(record ?? "null")).labels;
+}
+function labels_of(body, current) {
+  const intended = intended_labels(body);
+  const labels = current.filter((label) => !has_label_name([label], AUTO_OK_LABEL));
+  const decision = issue_auto_ok.decide({
+    is_opted_out: !has_label_name(intended, AUTO_OK_LABEL),
+    is_cross_repository: false,
+    body: public_body(body ?? ""),
+    labels
+  });
+  return decision.is_applied ? [...labels, AUTO_OK_LABEL] : labels;
+}
+function creation(body, labels, is_prepared) {
+  if (!is_prepared) return { body, labels };
+  return {
+    body: prepare(body, labels),
+    labels: labels.filter((label) => !has_label_name([label], AUTO_OK_LABEL))
+  };
+}
+var issue_publication_state = {
+  is_pending,
+  prepare,
+  carried,
+  public_body,
+  labels_of,
+  creation
+};
+
+export {
+  issue_publication_state
+};

package/dist/commands/chunk-5SOU366I.js

@@ -0,0 +1,252 @@
+import {
+  git_gh_issue_alias_graphql
+} from "./chunk-B762PNT6.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  observation_ledger_home,
+  observation_ledger_line
+} from "./chunk-N5FT5LYP.js";
+import {
+  CARRIED_ROUNDS_SUFFIX,
+  LEDGER_FILE_EXTENSION,
+  OBSERVATION_LEDGER_DIRECTORY
+} from "./chunk-SV4FZR24.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec,
+  parse_json,
+  parse_json_array_safe
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/observations/observation-ledger-archive.ts
+import { existsSync, readFileSync } from "node:fs";
+import { appendFile, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var ARCHIVE_PREFIX = "archive-";
+var ARCHIVED_ROUNDS_FILE = "archived-comment-rounds.txt";
+var ISSUE_FILE_PATTERN = new RegExp(
+  String.raw`^(?<issue>\d+)(?<rounds>${CARRIED_ROUNDS_SUFFIX})?\.md$`,
+  "u"
+);
+var CLOSED_FIELDS = "state closedAt";
+var CLOSED_STATE = "CLOSED";
+var MONTH_END = 7;
+var NONE = 0;
+var ARCHIVED_LINE = "closed issues' ledger file(s) moved into the monthly archive files.";
+var ARCHIVE_FAILED_LINE = "Could not archive the closed issues' ledger files; the next flush retries:";
+var closed_schema = z.object({ state: z.string(), closedAt: z.string().nullish() });
+function issue_file_of(name) {
+  const groups = ISSUE_FILE_PATTERN.exec(name)?.groups;
+  if (groups?.["issue"] === void 0) return void 0;
+  return { name, issue: Number(groups["issue"]), is_rounds: groups["rounds"] !== void 0 };
+}
+function issue_files(names) {
+  return names.toSorted((left, right) => left.localeCompare(right)).flatMap((name) => issue_file_of(name) ?? []);
+}
+function archive_name(closed_at) {
+  return `${ARCHIVE_PREFIX}${closed_at.slice(0, MONTH_END)}${LEDGER_FILE_EXTENSION}`;
+}
+async function closed_archives(issues) {
+  const read = await git_gh_issue_alias_graphql.read_aliased(issues, CLOSED_FIELDS, closed_schema);
+  return new Map(
+    [...read.answers].flatMap(
+      ([issue, answer]) => answer.state === CLOSED_STATE && typeof answer.closedAt === "string" ? [[issue, archive_name(answer.closedAt)]] : []
+    )
+  );
+}
+function by_archive(files, archives) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const target = archives.get(file.issue);
+    if (target !== void 0) groups.set(target, [...groups.get(target) ?? [], file]);
+  }
+  return groups;
+}
+async function move(directory, target, files) {
+  const contents = await Promise.all(
+    files.map(
+      async (file) => await observation_ledger_home.read_file(path.join(directory, file.name), true)
+    )
+  );
+  await appendFile(path.join(directory, target), contents.join(""), "utf8");
+  await Promise.all(
+    files.map(async (file) => {
+      await rm(path.join(directory, file.name));
+    })
+  );
+}
+function archived_rounds_path(root) {
+  return path.join(root, OBSERVATION_LEDGER_DIRECTORY, ARCHIVED_ROUNDS_FILE);
+}
+async function record_rounds(root, files) {
+  const issues = files.filter((file) => file.is_rounds).map((file) => String(file.issue));
+  if (issues.length > NONE) {
+    await appendFile(archived_rounds_path(root), `${issues.join("\n")}
+`, "utf8");
+  }
+}
+function archived_rounds(root) {
+  const target = archived_rounds_path(root);
+  if (!existsSync(target)) return /* @__PURE__ */ new Set();
+  return new Set(readFileSync(target, "utf8").split("\n").filter(Boolean).map(Number));
+}
+async function archive(root) {
+  const directory = path.join(root, OBSERVATION_LEDGER_DIRECTORY);
+  if (!existsSync(directory)) return NONE;
+  const files = issue_files(await readdir(directory));
+  const groups = by_archive(files, await closed_archives(files.map((file) => file.issue)));
+  const moved = [...groups.values()].flat();
+  await Promise.all(
+    [...groups].map(async ([name, group]) => {
+      await move(directory, name, group);
+    })
+  );
+  await record_rounds(root, moved);
+  return moved.length;
+}
+async function archive_reported(root) {
+  try {
+    const count = await archive(root);
+    if (count > NONE) console.info(`Archived ${String(count)} ${ARCHIVED_LINE}`);
+    return count;
+  } catch (error) {
+    console.warn(`${ARCHIVE_FAILED_LINE} ${error_text.message_of(error)}`);
+    return NONE;
+  }
+}
+var observation_ledger_archive = {
+  ARCHIVE_FAILED_LINE,
+  archive,
+  archive_reported,
+  archived_rounds
+};
+
+// scripts/review/review-comment-round.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+import { z as z2 } from "zod";
+var COMMENT_HEADING_MARK = "### ";
+var COMMENT_TITLE = "Review round recorded after the pull request opened";
+var OBSERVATION_TITLE = "Observation recorded while the pull request was open";
+var COMMENT_TITLES = [COMMENT_TITLE, OBSERVATION_TITLE];
+var COMMENT_HEADINGS = COMMENT_TITLES.map((title) => `${COMMENT_HEADING_MARK}${title}`);
+var COMMENT_NOTE = "Kept here rather than in the observation ledger: a line appended after the commit would be pushed onto the open pull request and restart its CI.";
+var CODE_FENCE = "```";
+var OBSERVATION_LINE_MARK = "- k:";
+var CARRIED_FILE_PATTERN = new RegExp(String.raw`^\d+${CARRIED_ROUNDS_SUFFIX}\.md$`, "u");
+var PER_PAGE = "100";
+var UNNAMED_REPOSITORY = "Could not name this repository from `git remote`.";
+var UNREAD_SEARCH = "Could not read the search for closed issues with a comment round.";
+var UNREAD_COMMENTS = "Could not read the comments of";
+var UNREAD_PERMISSION = "Could not read the write permission of";
+var search_item_schema = z2.object({ number: z2.number() });
+var search_schema = z2.object({ items: z2.array(search_item_schema) });
+var comment_schema = z2.object({
+  body: z2.string().nullish(),
+  author_association: z2.string().nullish(),
+  user: z2.looseObject({ login: z2.string() }).nullish()
+});
+function body_under(title, lines) {
+  const heading = `${COMMENT_HEADING_MARK}${title}`;
+  return [heading, "", COMMENT_NOTE, "", CODE_FENCE, ...lines, CODE_FENCE].join("\n");
+}
+function body_of(lines) {
+  return body_under(COMMENT_TITLE, lines);
+}
+function observation_body_of(lines) {
+  return body_under(OBSERVATION_TITLE, lines);
+}
+function is_carried_line(line) {
+  if (review_finding_ledger.is_finding_line(line)) return true;
+  return line.startsWith(OBSERVATION_LINE_MARK) && observation_ledger_line.line_reason(line) === void 0;
+}
+function is_round(comment) {
+  const body = comment.body ?? "";
+  return COMMENT_HEADINGS.some((heading) => body.startsWith(heading));
+}
+async function is_trusted_comment(comment) {
+  const login = comment.user?.login;
+  const is_trusted = await gh_author_association.trust_of({
+    login,
+    association: comment.author_association
+  });
+  if (is_trusted === void 0) throw new Error(`${UNREAD_PERMISSION} ${login ?? ""}`);
+  return is_trusted;
+}
+async function lines_of(comments) {
+  const rounds = comments.filter((comment) => is_round(comment));
+  const trusted = await Promise.all(
+    rounds.map(async (comment) => await is_trusted_comment(comment))
+  );
+  return rounds.filter((_comment, index) => trusted[index] === true).flatMap((comment) => (comment.body ?? "").split("\n")).filter((line) => is_carried_line(line));
+}
+function search_path(repo, title) {
+  const query = `repo:${repo} is:issue is:closed in:comments "${title}"`;
+  const parameters = new URLSearchParams({ q: query, sort: "updated", per_page: PER_PAGE });
+  return `search/issues?${parameters.toString()}`;
+}
+async function search(repo, title) {
+  const raw = await git_gh_exec.exec_gh_api({ path: search_path(repo, title) });
+  const page = parse_json.parse_json_object_or_undefined(raw, search_schema);
+  if (page === void 0) throw new Error(UNREAD_SEARCH);
+  return page.items.map((item) => item.number);
+}
+async function closed_issues() {
+  const repo = session_cite.session_repo();
+  if (repo === void 0) throw new Error(UNNAMED_REPOSITORY);
+  const pages = await Promise.all(COMMENT_TITLES.map(async (title) => await search(repo, title)));
+  return [...new Set(pages.flat())];
+}
+function carried_path(issue, root) {
+  return observation_ledger_home.file_path(`${String(issue)}${CARRIED_ROUNDS_SUFFIX}`, root);
+}
+function is_carried_file(file_path) {
+  return CARRIED_FILE_PATTERN.test(path2.basename(file_path));
+}
+async function issue_lines(issue) {
+  const raw = await git_gh_issue_read.issue_list_comments(String(issue));
+  if (raw === void 0) throw new Error(`${UNREAD_COMMENTS} ${session_cite.issue(issue)}`);
+  return await lines_of(parse_json_array_safe(raw, comment_schema));
+}
+async function carry_issue(issue, root) {
+  const lines = await issue_lines(issue);
+  await observation_ledger_home.append(carried_path(issue, root), lines);
+  return lines.length;
+}
+async function carry(root) {
+  const issues = await closed_issues();
+  const archived = observation_ledger_archive.archived_rounds(root);
+  const pending = issues.filter(
+    (issue) => !archived.has(issue) && !existsSync2(carried_path(issue, root))
+  );
+  const counts = await Promise.all(pending.map(async (issue) => await carry_issue(issue, root)));
+  return counts.reduce((total, count) => total + count, 0);
+}
+var review_comment_round = {
+  body_of,
+  carried_path,
+  carry,
+  is_carried_file,
+  issue_lines,
+  lines_of,
+  observation_body_of
+};
+
+export {
+  observation_ledger_archive,
+  review_comment_round
+};

package/dist/commands/chunk-5VUHAXPI.js

@@ -0,0 +1,77 @@
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  git_location_environment,
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  COMMAND_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/init/start-exec.ts
+import { execaSync } from "execa";
+var SUCCESS_EXIT_CODE = 0;
+var GIT_DIRECTORY = ".git";
+var IDENTITY_VARIABLES = ["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"];
+function root_environment() {
+  return git_location_environment.location_free_environment();
+}
+function git_succeeds(args, root) {
+  return git_spawn_sync.run(args, { cwd: root, env: root_environment() }).exit_code === 0;
+}
+function git_read(args, root) {
+  return git_spawn_sync.read(args, { cwd: root, env: root_environment() });
+}
+function is_identity_refused(variable, options) {
+  const { exit_code } = git_spawn_sync.run(["var", variable], options);
+  return exit_code !== void 0 && exit_code !== SUCCESS_EXIT_CODE;
+}
+function lacks_git_identity(root, is_new_repository) {
+  const location = is_new_repository ? { GIT_DIR: GIT_DIRECTORY } : {};
+  const options = { cwd: root, env: { ...root_environment(), ...location } };
+  return IDENTITY_VARIABLES.some((variable) => is_identity_refused(variable, options));
+}
+function git_run(args, root) {
+  const options = { cwd: root, env: root_environment(), timeout: SUITE_TIMEOUT_MS };
+  const { exit_code } = git_spawn_sync.run(args, { ...options, stdio: "inherit" });
+  if (exit_code === SUCCESS_EXIT_CODE) return;
+  const outcome = exit_code === void 0 ? "did not finish" : `exited with ${String(exit_code)}`;
+  throw new Error(`git ${args.join(" ")} ${outcome}`);
+}
+function gh_probe_options(root) {
+  const environment = { ...root_environment(), ...git_gh_exec.direct_environment().env };
+  return { cwd: root, env: environment, timeout: COMMAND_TIMEOUT_MS, reject: false };
+}
+function is_gh_installed(root) {
+  const result = execaSync("gh", ["--version"], gh_probe_options(root));
+  return result.exitCode === SUCCESS_EXIT_CODE;
+}
+function is_gh_signed_in(root) {
+  const result = execaSync("gh", ["auth", "status"], gh_probe_options(root));
+  return result.exitCode === SUCCESS_EXIT_CODE;
+}
+function create_github_repository(name, visibility, root) {
+  const source = ["--source", ".", "--remote", "origin", "--push"];
+  const { env } = gh_probe_options(root);
+  const options = { cwd: root, env, timeout: SUITE_TIMEOUT_MS, stdio: "inherit" };
+  execaSync("gh", ["repo", "create", name, `--${visibility}`, ...source], options);
+}
+function run_local(command, args, root) {
+  execaSync(command, args, { cwd: root, stdio: "inherit" });
+}
+var start_exec = {
+  git_succeeds,
+  git_read,
+  git_run,
+  lacks_git_identity,
+  is_gh_installed,
+  is_gh_signed_in,
+  create_github_repository,
+  run_local
+};
+
+export {
+  start_exec
+};