@joshuafolkken/kit 1.3000.0 → 1.3041.0

package/dist/commands/chunk-CKUKK7JG.js

@@ -0,0 +1,252 @@
+import {
+  git_gh_issue_alias_graphql
+} from "./chunk-HWEZRNPL.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  observation_ledger_home,
+  observation_ledger_line
+} from "./chunk-WWVYEHQT.js";
+import {
+  CARRIED_ROUNDS_SUFFIX,
+  LEDGER_FILE_EXTENSION,
+  OBSERVATION_LEDGER_DIRECTORY
+} from "./chunk-SV4FZR24.js";
+import {
+  git_gh_issue_read
+} from "./chunk-ENKFCOVY.js";
+import {
+  gh_author_association
+} from "./chunk-XXNEY4B3.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec,
+  parse_json,
+  parse_json_array_safe
+} from "./chunk-XDF25GSU.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-4PES3BAA.js → chunk-CMHGDCGN.js}

@@ -1,13 +1,13 @@
 import {
   issue_read_cli
-} from "./chunk-4LWRCPS5.js";
+} from "./chunk-VOF3N4WO.js";
 import {
   agent_diagnostics,
   claude_agent_argv
-} from "./chunk-OHVAEJSM.js";
+} from "./chunk-DEZF7QZZ.js";
 import {
   agent_role_profile
-} from "./chunk-RIQ75QWR.js";
+} from "./chunk-6UCWAFQY.js";
 import {
   agent_event
 } from "./chunk-LULJUD6P.js";

package/dist/commands/{chunk-F6OWP2AY.js → chunk-CNGTHSUS.js}

@@ -1,24 +1,24 @@
 import {
   git_preflight
-} from "./chunk-US6X7JXC.js";
+} from "./chunk-Q7EEIOAD.js";
 import {
   acceptance_map_check
-} from "./chunk-PZTWQYRI.js";
+} from "./chunk-IYJEBWW5.js";
 import {
   git_pr
-} from "./chunk-JB7R3A4A.js";
+} from "./chunk-YDURQICF.js";
 import {
   run_ship_body_draft
-} from "./chunk-J3G2R64I.js";
+} from "./chunk-3ZOX4G4U.js";
 import {
   removed_tests_check
-} from "./chunk-4HBVHYNL.js";
+} from "./chunk-47UZB54M.js";
 import {
   live_evidence
-} from "./chunk-KVJDDECB.js";
+} from "./chunk-3B2HEFNO.js";
 import {
   acceptance_map
-} from "./chunk-SK2LJBFS.js";
+} from "./chunk-5PCK53WP.js";
 import {
   josh_command
 } from "./chunk-2VRITY55.js";
@@ -27,30 +27,30 @@ import {
 } from "./chunk-7IZJ5MG2.js";
 import {
   run_ship_planned
-} from "./chunk-ESQEEL4O.js";
+} from "./chunk-TAEGXID2.js";
 import {
   git_issue
-} from "./chunk-VD5674LW.js";
+} from "./chunk-HI5WPM6C.js";
 import {
   git_gh_command
-} from "./chunk-RX5JSPPH.js";
+} from "./chunk-YGFOGA7C.js";
 import {
   gate_ledger,
   whole_tree_reuse
-} from "./chunk-3EO2XN3A.js";
+} from "./chunk-JCAQ7B6J.js";
 import {
   check_reuse
-} from "./chunk-O5FVBIRI.js";
+} from "./chunk-KZ5BBBMO.js";
 import {
   test_related_synced
-} from "./chunk-SV4FHQE7.js";
+} from "./chunk-LT7QSHR4.js";
 import {
   gate_skip
-} from "./chunk-DNJC7X73.js";
+} from "./chunk-WCEUMOKK.js";
 import {
   related_scope,
   whole_suite_files
-} from "./chunk-7EAMUVIO.js";
+} from "./chunk-CFHRNTE5.js";
 import {
   report_format_reference
 } from "./chunk-Q6SKKQVJ.js";
@@ -59,22 +59,22 @@ import {
 } from "./chunk-PE7B7242.js";
 import {
   metrics_totals
-} from "./chunk-UU6GCJGM.js";
+} from "./chunk-ORKVN2LO.js";
 import {
   scoped_green
-} from "./chunk-BK6Q4VCA.js";
+} from "./chunk-WTH6NTXU.js";
 import {
   since_green
-} from "./chunk-SNO7CY2B.js";
+} from "./chunk-P3H3DKTE.js";
 import {
   test_read_map
 } from "./chunk-OZZWRJQI.js";
 import {
   review_stamps
-} from "./chunk-L6LU2633.js";
+} from "./chunk-MVHPRYHE.js";
 import {
   gate_tree
-} from "./chunk-IXX4SXIP.js";
+} from "./chunk-NFPD2P3V.js";
 import {
   file_map_stamp
 } from "./chunk-CGLLAEKZ.js";
@@ -83,7 +83,7 @@ import {
 } from "./chunk-WL5JHB3I.js";
 import {
   verification_inputs
-} from "./chunk-REMKUFAC.js";
+} from "./chunk-34KZDKQJ.js";
 import {
   changed_file_scope
 } from "./chunk-7LJQMM2K.js";
@@ -101,7 +101,7 @@ import {
 } from "./chunk-CDY4NFQG.js";
 import {
   buffered_process
-} from "./chunk-D5TAR6TV.js";
+} from "./chunk-JZHY7D6D.js";
 import {
   changed_paths
 } from "./chunk-V5FD7DVV.js";

package/dist/commands/{chunk-B2EA2HCY.js → chunk-COGKULQH.js}

@@ -1,15 +1,15 @@
 import {
   baseline_measure
-} from "./chunk-RZJAUVMI.js";
+} from "./chunk-BMM4RHCG.js";
 import {
   reproduction_measure
-} from "./chunk-D4SZK7H2.js";
+} from "./chunk-6TIVDEKG.js";
 import {
   markdown_section
-} from "./chunk-CRNPPKP2.js";
+} from "./chunk-JZK33TA5.js";
 import {
   issue_body_keys
-} from "./chunk-FNQW6NY7.js";
+} from "./chunk-KXK2A2HB.js";
 
 // scripts/rules/firing-point.ts
 var HOOK_DELIVERABLE_TOOLS = [