@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/dist/commands/chunk-E2ZCUKHT.js

@@ -1,274 +0,0 @@
-import {
-  CHECK_STATUS_FAIL,
-  CHECK_STATUS_PASS,
-  CHECK_STATUS_PENDING,
-  PrConflictError,
-  is_coderabbit_check,
-  is_coderabbit_rate_limited
-} from "./chunk-WVR4RUFP.js";
-import {
-  time_format
-} from "./chunk-6NV2F7QH.js";
-import {
-  run_event_stream_emit
-} from "./chunk-34LAULSC.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-
-// scripts/followup/followup-ci-path.ts
-function new_path() {
-  return { pending: /* @__PURE__ */ new Set(), settled: /* @__PURE__ */ new Set(), check_ms: {} };
-}
-function settle(path, name, elapsed_ms) {
-  if (path.pending.delete(name)) path.check_ms[name] = elapsed_ms;
-  path.settled.add(name);
-}
-function hold(path, name) {
-  if (path.settled.has(name)) path.has_rerun = true;
-  path.pending.add(name);
-}
-function observe(path, snapshot, now_ms) {
-  path.start_ms ??= now_ms;
-  const elapsed_ms = now_ms - path.start_ms;
-  const checks = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  const pending = new Set(
-    checks.filter((check) => check.status === CHECK_STATUS_PENDING).map((check) => check.name)
-  );
-  for (const name of pending) hold(path, name);
-  for (const check of checks) if (!pending.has(check.name)) settle(path, check.name, elapsed_ms);
-}
-function observer_of(path) {
-  const is_first_wait = path.start_ms === void 0;
-  return async function time_checks(snapshot) {
-    if (is_first_wait) observe(path, snapshot, performance.now());
-  };
-}
-function record_of(path) {
-  const [last] = Object.entries(path.check_ms).toSorted((left, right) => right[1] - left[1]);
-  if (last === void 0) return {};
-  return {
-    last_check: last[0],
-    check_ms: { ...path.check_ms },
-    ...path.has_rerun && { has_rerun: path.has_rerun }
-  };
-}
-var followup_ci_path = { new_path, observe, observer_of, record_of };
-
-// scripts/run/event/run-event-checks.ts
-var CODERABBIT_STATES = ["running", "done", "rate-limited", "failed", "none"];
-var CHECKS_PATTERN = /^#\d+ PR (?<pr>\d+) pass (?<pass>\d+) pending (?<pending>\d+) fail (?<fail>\d+) coderabbit (?<coderabbit>\S+)$/u;
-function text_of(issue, checks) {
-  const { pr, pass, pending, fail, coderabbit } = checks;
-  return `${issue_cite.plain_for("program", issue)} PR ${String(pr)} pass ${String(pass)} pending ${String(pending)} fail ${String(fail)} coderabbit ${coderabbit}`;
-}
-var STATE_NAMES = new Set(CODERABBIT_STATES);
-function is_coderabbit_state(value = "") {
-  return STATE_NAMES.has(value);
-}
-function checks_of(text) {
-  const groups = CHECKS_PATTERN.exec(text)?.groups;
-  const coderabbit = groups?.["coderabbit"];
-  if (groups === void 0 || !is_coderabbit_state(coderabbit)) return void 0;
-  return {
-    pr: Number(groups["pr"]),
-    pass: Number(groups["pass"]),
-    pending: Number(groups["pending"]),
-    fail: Number(groups["fail"]),
-    coderabbit
-  };
-}
-var run_event_checks = { checks_of, text_of };
-
-// scripts/followup/followup-checks-event.ts
-var PR_NUMBER_PATTERN = /\/pull\/(?<number>\d+)/u;
-var { PR_CHECKS } = run_event_stream.EVENT_KIND;
-function count_of(checks, status) {
-  return checks.filter((check) => check.status === status).length;
-}
-function coderabbit_state_of(check) {
-  if (check === void 0) return "none";
-  if (check.status === CHECK_STATUS_PENDING) return "running";
-  if (check.status !== CHECK_STATUS_PASS) return "failed";
-  return is_coderabbit_rate_limited(check) ? "rate-limited" : "done";
-}
-function coderabbit_of(snapshot) {
-  return coderabbit_state_of(snapshot.rollup.find((check) => is_coderabbit_check(check.name)));
-}
-function summary_of(snapshot, pr) {
-  const ci = snapshot.rollup.filter((check) => !is_coderabbit_check(check.name));
-  return {
-    pr,
-    pass: count_of(ci, CHECK_STATUS_PASS),
-    pending: count_of(ci, CHECK_STATUS_PENDING),
-    fail: count_of(ci, CHECK_STATUS_FAIL),
-    coderabbit: coderabbit_of(snapshot)
-  };
-}
-function pr_number_of(pr_url = "") {
-  const number = PR_NUMBER_PATTERN.exec(pr_url)?.groups?.["number"];
-  return number === void 0 ? void 0 : Number(number);
-}
-async function skip_snapshot() {
-}
-function observer_of2(issue, pr_url) {
-  const pr = pr_number_of(pr_url);
-  if (issue === void 0 || pr === void 0) return skip_snapshot;
-  let last_text = "";
-  return async function report_snapshot(snapshot) {
-    const text = run_event_checks.text_of(issue, summary_of(snapshot, pr));
-    if (text === last_text) return;
-    last_text = text;
-    await run_event_stream_emit.emit(PR_CHECKS, text);
-  };
-}
-var followup_checks_event = { coderabbit_of, observer_of: observer_of2, summary_of };
-
-// scripts/followup/followup-coderabbit-wait.ts
-var NO_TIME = 0;
-var RATE_LIMITED = "rate-limited";
-var WAITING_STATES = /* @__PURE__ */ new Set(["running", RATE_LIMITED]);
-function new_wait() {
-  return { wait_ms: NO_TIME, rate_limited_ms: NO_TIME };
-}
-function charge(wait, last, now_ms) {
-  const elapsed_ms = now_ms - last.at_ms;
-  if (WAITING_STATES.has(last.state)) wait.wait_ms += elapsed_ms;
-  if (last.state === RATE_LIMITED) wait.rate_limited_ms += elapsed_ms;
-}
-function observe2(wait, snapshot, now_ms) {
-  if (wait.last !== void 0) charge(wait, wait.last, now_ms);
-  wait.last = { state: followup_checks_event.coderabbit_of(snapshot), at_ms: now_ms };
-}
-function observer_of3(wait) {
-  delete wait.last;
-  return async function time_snapshot(snapshot) {
-    observe2(wait, snapshot, performance.now());
-  };
-}
-function all(...observers) {
-  return async function observe_all(snapshot) {
-    await Promise.all(
-      observers.map(async (observer) => {
-        await observer(snapshot);
-      })
-    );
-  };
-}
-async function record_part(stage, elapsed_ms) {
-  if (elapsed_ms > NO_TIME) await lane_ledger_write.record_stage({ stage, elapsed_ms });
-}
-async function record(wait) {
-  await record_part(lane_ledger_write.CODERABBIT_WAIT_STAGE, wait.wait_ms);
-  await record_part(lane_ledger_write.CODERABBIT_RATE_LIMIT_STAGE, wait.rate_limited_ms);
-}
-var followup_coderabbit_wait = { all, new_wait, observe: observe2, observer_of: observer_of3, record };
-
-// scripts/followup/git-followup-stages.ts
-var STAGE_LINE_PREFIX = "followup stage: ";
-var STAGE_TOTAL_PREFIX = "followup stages total: ";
-var STAGE_NAME_WIDTH = 26;
-var VALUE_COLUMN = STAGE_LINE_PREFIX.length + STAGE_NAME_WIDTH;
-var NO_DURATION = 0;
-var STAGE = {
-  closes_and_context: "closes-and-context",
-  checks_wait: "checks-wait",
-  // Only on a run that retriggered a rate-limited CodeRabbit: the window and the review after it
-  // (joshuafolkken/kit#5289), kept out of `checks-wait` so the `ci-wait` row is the checks alone.
-  coderabbit_retrigger: "coderabbit-retrigger",
-  coderabbit_comments: "coderabbit-comments",
-  ai_review_comments: "ai-review-comments",
-  // The interval of a run that merged nothing, where the send has nothing to go beside.
-  telegram: "telegram",
-  telegram_and_merge: "telegram-and-merge",
-  completion_and_epic_close: "completion-and-epic-close",
-  // The completion tail `git-followup-finish.ts` prints after this block (#5131): the next-issue list
-  // and the unreleased-merge count. Printed as its own row there, since the block is already out.
-  completion: "completion",
-  // The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
-  // blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
-  // them would leave the measurement blind to exactly the invocations worth measuring.
-  interrupted: "interrupted",
-  // The interrupted lap when the wait failed on a merge conflict, so the
-  // stage block names the cause a resumed session would otherwise look up with `gh pr view`.
-  conflict: "conflict"
-};
-function stopped_lap(error) {
-  return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted;
-}
-function new_log() {
-  return {
-    stages: [],
-    last_ms: performance.now(),
-    coderabbit: followup_coderabbit_wait.new_wait(),
-    ci_path: followup_ci_path.new_path(),
-    reran: []
-  };
-}
-function hold_issue(log, issue_number) {
-  const issue = Number(issue_number);
-  if (Number.isSafeInteger(issue) && issue > 0) log.issue = issue;
-}
-function lap(log, name) {
-  const now_ms = performance.now();
-  log.stages.push({ name, duration_ms: now_ms - log.last_ms });
-  log.last_ms = now_ms;
-}
-function total_ms(stages) {
-  return stages.reduce((sum, stage) => sum + stage.duration_ms, NO_DURATION);
-}
-function format_stage(stage) {
-  const name = stage.name.padEnd(STAGE_NAME_WIDTH);
-  return `${STAGE_LINE_PREFIX}${name}${time_format.format_seconds(stage.duration_ms)}`;
-}
-function format_stages(log) {
-  if (log.stages.length === 0) return [];
-  const rows = log.stages.map((stage) => format_stage(stage));
-  const total = time_format.format_seconds(total_ms(log.stages));
-  return ["", ...rows, `${STAGE_TOTAL_PREFIX.padEnd(VALUE_COLUMN)}${total}`];
-}
-function print_stages(log) {
-  for (const line of format_stages(log)) console.info(line);
-}
-async function record_ci_wait(log) {
-  const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait);
-  if (wait === void 0) return;
-  await lane_ledger_write.record_stage({
-    stage: lane_ledger_write.CI_WAIT_STAGE,
-    elapsed_ms: wait.duration_ms,
-    ...log.issue !== void 0 && { issue: log.issue },
-    ...followup_ci_path.record_of(log.ci_path)
-  });
-}
-async function record_waits(log) {
-  await record_ci_wait(log);
-  await followup_coderabbit_wait.record(log.coderabbit);
-}
-var git_followup_stages = {
-  STAGE,
-  STAGE_LINE_PREFIX,
-  STAGE_TOTAL_PREFIX,
-  new_log,
-  hold_issue,
-  lap,
-  total_ms,
-  format_stage,
-  format_stages,
-  print_stages,
-  record_waits,
-  stopped_lap
-};
-
-export {
-  followup_ci_path,
-  run_event_checks,
-  followup_checks_event,
-  followup_coderabbit_wait,
-  git_followup_stages
-};

package/dist/commands/chunk-NMLCPYBN.js

@@ -1,134 +0,0 @@
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  observation_ledger_home,
-  observation_ledger_line
-} from "./chunk-WG6GYBRJ.js";
-import {
-  git_gh_issue_read
-} from "./chunk-LRA3PXHS.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  session_cite
-} from "./chunk-X7PN54LZ.js";
-import {
-  git_gh_exec,
-  parse_json,
-  parse_json_array_safe
-} from "./chunk-XDF25GSU.js";
-
-// scripts/review/review-comment-round.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { z } 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_SUFFIX = "-comment-rounds";
-var CARRIED_FILE_PATTERN = new RegExp(String.raw`^\d+${CARRIED_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 = z.object({ number: z.number() });
-var search_schema = z.object({ items: z.array(search_item_schema) });
-var comment_schema = z.object({
-  body: z.string().nullish(),
-  author_association: z.string().nullish(),
-  user: z.looseObject({ login: z.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_SUFFIX}`, root);
-}
-function is_carried_file(file_path) {
-  return CARRIED_FILE_PATTERN.test(path.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 pending = issues.filter((issue) => !existsSync(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 {
-  review_comment_round
-};