@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-2OEXY4GM.js

@@ -1,252 +0,0 @@
-import {
-  git_gh_issue_alias_graphql
-} from "./chunk-XAEL24EG.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  observation_ledger_home,
-  observation_ledger_line
-} from "./chunk-QXBOECGL.js";
-import {
-  CARRIED_ROUNDS_SUFFIX,
-  LEDGER_FILE_EXTENSION,
-  OBSERVATION_LEDGER_DIRECTORY
-} from "./chunk-SV4FZR24.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  gh_author_association
-} from "./chunk-5YTEMF4O.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  git_gh_exec,
-  parse_json,
-  parse_json_array_safe
-} from "./chunk-43DU7DYZ.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-2ONSHOAY.js

@@ -1,46 +0,0 @@
-import {
-  git_command,
-  git_diff_reads
-} from "./chunk-IXZZSST7.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  UNTRACKED_FILES_FLAG
-} from "./chunk-B5GXZK3E.js";
-
-// scripts/run/cut/run-cut-ready.ts
-function is_ready(tree) {
-  return tree.branch !== tree.default_branch && tree.is_dirty;
-}
-async function is_lane_branch(state) {
-  const default_branch = await git_command.get_default_branch();
-  return is_ready({ branch: state.branch, default_branch, is_dirty: state.is_dirty });
-}
-var STATUS_ARGUMENTS = ["status", "--porcelain=v2", "--branch", UNTRACKED_FILES_FLAG];
-var HEADER_PREFIX = "#";
-var BRANCH_HEADER = "# branch.head ";
-function tree_of(status, default_branch) {
-  const lines = status.split("\n").filter((line) => line !== "");
-  const header = lines.find((line) => line.startsWith(BRANCH_HEADER));
-  if (header === void 0) return void 0;
-  const branch = header.slice(BRANCH_HEADER.length);
-  const is_dirty = lines.some((line) => !line.startsWith(HEADER_PREFIX));
-  return { branch, default_branch, is_dirty };
-}
-function read_tree_sync(cwd) {
-  const options = git_spawn_sync.located(cwd);
-  const status = git_spawn_sync.read(STATUS_ARGUMENTS, options);
-  if (status === void 0) return void 0;
-  const reference = git_spawn_sync.read(git_diff_reads.DEFAULT_BRANCH_ARGUMENTS, options);
-  return tree_of(status, git_diff_reads.default_branch_of(reference));
-}
-function is_ready_sync(read = read_tree_sync) {
-  const tree = read();
-  return tree === void 0 || is_ready(tree);
-}
-var run_cut_ready = { is_lane_branch, is_ready, is_ready_sync, read_tree_sync, tree_of };
-
-export {
-  run_cut_ready
-};

package/dist/commands/chunk-2SA3W4JF.js

@@ -1,41 +0,0 @@
-import {
-  release_history,
-  release_plan
-} from "./chunk-RGRLLF2J.js";
-import {
-  version_targets
-} from "./chunk-LPSULLNK.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-
-// scripts/followup/git-followup-pending.ts
-var MERGE_PENDING_NOTE = "\u2014 this run's merge is not counted; it lands next";
-async function read_tip(options) {
-  if (options.tip !== void 0) return options.tip;
-  const default_branch = await git_command.get_default_branch();
-  await git_command.fetch_branch(default_branch);
-  return `origin/${default_branch}`;
-}
-async function read_pending(options) {
-  try {
-    const current_version = version_targets.read_workspace_version(options.cwd ?? process.cwd());
-    if (current_version === void 0) return void 0;
-    const tip = await read_tip(options);
-    const plan = await release_history.read_release_plan(current_version, options.reader, tip);
-    return plan?.pending;
-  } catch {
-    return void 0;
-  }
-}
-async function pending_release_line(options) {
-  const pending = await read_pending(options);
-  if (pending === void 0) return void 0;
-  const line = release_plan.format_pending_line(pending);
-  return options.is_merge_pending ? `${line} ${MERGE_PENDING_NOTE}` : line;
-}
-var git_followup_pending = { MERGE_PENDING_NOTE, pending_release_line, read_pending };
-
-export {
-  git_followup_pending
-};

package/dist/commands/chunk-2VY7CJ2R.js

@@ -1,212 +0,0 @@
-import {
-  declared_growth,
-  split_assess
-} from "./chunk-ZGEUWHFF.js";
-import {
-  lane_stage_budget
-} from "./chunk-AXXEMVRJ.js";
-import {
-  lane_implement_rate
-} from "./chunk-KP2BVAS5.js";
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  SPLIT_ROUTE_LABEL
-} from "./chunk-QQBMVC5W.js";
-
-// scripts/issue/size-estimate.ts
-import { z } from "zod";
-var BACKGROUND_HEADING = issue_body_keys.heading("background");
-var EPIC_HEADING = "## Split rationale";
-var PREFIX = issue_body_keys.prefix("size");
-var HEADING_PREFIX = "## ";
-var { REASON_PREFIX } = split_assess;
-var DECLARATION = `${PREFIX} ${issue_body_keys.size_value("<N>", "<M>")}`;
-var MISSING = `missing size estimate: declare \`${DECLARATION}\` under ${BACKGROUND_HEADING}`;
-var EXAMPLE = `${PREFIX} ${issue_body_keys.size_value("3", "60")}`;
-var MALFORMED = `\`${PREFIX}\` must be written ${DECLARATION}
-${EXAMPLE}`;
-var estimate_schema = z.object({ files: z.coerce.number(), lines: z.coerce.number() });
-var IMPLEMENT_BUDGET = lane_stage_budget.BUDGET_MINUTES.implement;
-var BAR_BUDGETS = 2;
-var BAR_MINUTES = BAR_BUDGETS * IMPLEMENT_BUDGET;
-function declared(body, prefix) {
-  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_estimate_line(text) {
-  const trimmed = text.trim();
-  return trimmed.startsWith(PREFIX) && issue_body_keys.size_counts(trimmed.slice(PREFIX.length).trim()) !== void 0;
-}
-function stated_line(record) {
-  return markdown_section.unfenced_lines(record).find((text) => is_estimate_line(text))?.trim();
-}
-function declared_index(visible) {
-  const start = visible.findIndex((text) => text.trim() === BACKGROUND_HEADING) + 1;
-  if (start === 0) return -1;
-  const section = visible.slice(start);
-  const end = section.findIndex((text) => text.trimStart().startsWith(HEADING_PREFIX));
-  const bounded = end === -1 ? section : section.slice(0, end);
-  const at = bounded.findIndex((text) => text.trimStart().startsWith(PREFIX));
-  return at === -1 ? -1 : start + at;
-}
-function restated(body, line) {
-  const lines = [...markdown_section.lines_of(body)];
-  const at = declared_index(markdown_section.unfenced_lines(body));
-  const current = lines[at];
-  if (current === void 0) return body;
-  lines[at] = `${current.slice(0, current.length - current.trimStart().length)}${line}`;
-  return lines.join("\n");
-}
-function is_epic(body) {
-  return markdown_section.has_line(body, EPIC_HEADING);
-}
-function grown(count, axis, growth) {
-  return count * declared_growth.factor(growth, axis);
-}
-function guide_for(rate) {
-  return split_assess.guide_for(IMPLEMENT_BUDGET, rate);
-}
-function parse(body, rate, growth) {
-  const read = estimate_schema.safeParse(issue_body_keys.size_counts(declared(body, PREFIX) ?? ""));
-  if (!read.success) return void 0;
-  const { files, lines } = read.data;
-  return {
-    files,
-    lines,
-    verdict: split_assess.verdict_for(
-      grown(files, "files", growth),
-      grown(lines, "lines", growth),
-      guide_for(rate)
-    )
-  };
-}
-function growth_text(growth) {
-  return growth?.files === void 0 && growth?.lines === void 0 ? `\xD7 ${String(declared_growth.factor(growth, "files"))}` : `(${declared_growth.text(growth)})`;
-}
-function projected(estimate, growth) {
-  const declared_counts = `${String(estimate.files)} file(s) / ${String(estimate.lines)} line(s)`;
-  const grown_counts = `${String(grown(estimate.files, "files", growth))} file(s) / ${String(grown(estimate.lines, "lines", growth))} line(s)`;
-  return `size estimate ${declared_counts} ${growth_text(growth)} = ${grown_counts}`;
-}
-function problems(body) {
-  if (is_epic(body)) return [];
-  if (declared(body, PREFIX) === void 0) return [MISSING];
-  return parse(body) === void 0 ? [MALFORMED] : [];
-}
-function is_reasoned(body) {
-  return (declared(body, REASON_PREFIX) ?? "") !== "";
-}
-function is_excused(body, route) {
-  return route === SPLIT_ROUTE_LABEL || is_reasoned(body);
-}
-function exceeded(estimate, rate, growth) {
-  if (estimate.verdict === split_assess.SINGLE_VERDICT) return projected(estimate, growth);
-  const guide = guide_for(rate);
-  return `${projected(estimate, growth)} exceeds the guide (more than ${String(guide.files)} files or ${String(guide.lines)} lines)`;
-}
-function refusal(estimate, rate, growth) {
-  return `${exceeded(estimate, rate, growth)} \u2014 file it split (\`--route split\`) or declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
-}
-function guide_exceeded(body, rate, growth) {
-  const estimate = parse(body, rate, growth);
-  return estimate?.verdict === split_assess.SPLIT_VERDICT ? estimate : void 0;
-}
-function over_guide(body, route, rate, growth) {
-  return is_excused(body, route) ? void 0 : guide_exceeded(body, rate, growth);
-}
-function split_over_guide(body, route, rate, growth) {
-  return route === SPLIT_ROUTE_LABEL ? guide_exceeded(body, rate, growth) : void 0;
-}
-function over_cap(body, route, rate, growth) {
-  const estimate = parse(body, rate, growth);
-  if (estimate === void 0 || is_excused(body, route)) return void 0;
-  return split_assess.is_over_cap(
-    grown(estimate.files, "files", growth),
-    grown(estimate.lines, "lines", growth),
-    guide_for(rate)
-  ) ? estimate : void 0;
-}
-function route_of(labels) {
-  return labels.includes(SPLIT_ROUTE_LABEL) ? SPLIT_ROUTE_LABEL : void 0;
-}
-function capped(estimate, rate, growth) {
-  const { cap } = guide_for(rate);
-  return `${projected(estimate, growth)} exceeds the cap (more than ${String(cap.files)} files or ${String(cap.lines)} lines) with no \`${REASON_PREFIX}\``;
-}
-function cap_refusal(estimate, rate, growth) {
-  return `${capped(estimate, rate, growth)} \u2014 with separately-mergeable parts, file an ordered epic of \`--route split\` children (the mechanical changes first, the child that switches the setting on last); one deliverable, declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
-}
-function projected_minutes(estimate, rate, growth) {
-  return lane_implement_rate.minutes_for(grown(estimate.lines, "lines", growth), rate);
-}
-function declared_lines_bar(rate, growth) {
-  const lines = lane_implement_rate.lines_for(BAR_MINUTES, rate);
-  return lines === void 0 ? void 0 : Math.floor(lines / declared_growth.factor(growth, "lines"));
-}
-function unreasoned(body, rate, growth) {
-  return is_reasoned(body) ? void 0 : parse(body, rate, growth);
-}
-function bar_overrun(body, rate, growth) {
-  const estimate = unreasoned(body, rate, growth);
-  if (estimate === void 0 || rate === void 0) return void 0;
-  const bar = declared_lines_bar(rate, growth);
-  return bar !== void 0 && estimate.lines > bar ? { estimate, rate, bar } : void 0;
-}
-function overrun_text(overrun, growth) {
-  const { estimate, rate, bar } = overrun;
-  const minutes = Math.round(projected_minutes(estimate, rate, growth));
-  const measured = `${rate.median.toFixed(1)} implement min / 100 lines over ${String(rate.lanes)} lane(s)`;
-  const limit = `the ${String(BAR_MINUTES)}-minute size bar (${String(BAR_BUDGETS)} \xD7 the ${String(IMPLEMENT_BUDGET)}-minute implement budget: at most ${String(bar)} declared line(s))`;
-  return `${exceeded(estimate, rate, growth)} and projects ${String(minutes)} implement minute(s) at ${measured}, over ${limit}`;
-}
-function over_budget(body, rate, growth) {
-  return bar_overrun(body, rate, growth)?.estimate;
-}
-function budget_note(body, rate, growth) {
-  const overrun = bar_overrun(body, rate, growth);
-  return overrun === void 0 ? void 0 : overrun_text(overrun, growth);
-}
-function budget_problem(body, rate, growth) {
-  const note = budget_note(body, rate, growth);
-  return note === void 0 ? void 0 : `${note} \u2014 split it into children each within the bar or declare \`${REASON_PREFIX} <\u7406\u7531>\`; split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
-}
-function guide_problem(body, route, rate, growth) {
-  const over = over_cap(body, route, rate, growth);
-  if (over !== void 0) return cap_refusal(over, rate, growth);
-  const estimate = over_guide(body, route, rate, growth);
-  const guide_refusal = estimate === void 0 ? void 0 : refusal(estimate, rate, growth);
-  return budget_problem(body, rate, growth) ?? guide_refusal;
-}
-function declared_files(body) {
-  return parse(body)?.files;
-}
-var size_estimate = {
-  budget_note,
-  capped,
-  declared,
-  declared_files,
-  declared_lines_bar,
-  declared_size: parse,
-  exceeded,
-  guide_problem,
-  is_epic,
-  over_budget,
-  over_cap,
-  over_guide,
-  problems,
-  projected_minutes,
-  restated,
-  route_of,
-  split_over_guide,
-  stated_line
-};
-
-export {
-  size_estimate
-};

package/dist/commands/chunk-2WRDAQPJ.js

@@ -1,74 +0,0 @@
-import {
-  issue_read
-} from "./chunk-3F3RNIG2.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/issue/issue-outcome.ts
-import { z } from "zod";
-var SUMMARY_LIMIT = 80;
-var summary_schema = z.string().min(1).max(SUMMARY_LIMIT).regex(/^[\u{20}-\u{7E}]+$/u).refine((value) => value === value.trim());
-var MARKER = /^<!-- josh:outcome (?<json>[^\n]+) -->$/gmu;
-var COMMENT_URL = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+#issuecomment-\d+$(?![\s\S])/u;
-var url_schema = z.string().regex(COMMENT_URL);
-var outcome_schema = z.object({ summary: summary_schema, url: url_schema.optional() });
-function body_of(note) {
-  if (note.summary === void 0 && note.url === void 0) return note.body;
-  const outcome = outcome_schema.parse({ summary: note.summary, url: note.url });
-  return `${note.body}
-
-<!-- josh:outcome ${JSON.stringify(outcome)} -->`;
-}
-function evidence_of(comment, url) {
-  if (comment.html_url === void 0 || !COMMENT_URL.test(url)) return false;
-  return url.split("#", 1)[0] === comment.html_url.split("#", 1)[0];
-}
-function record_of(body) {
-  const json = [...body.matchAll(MARKER)].at(-1)?.groups?.["json"];
-  return json_value.parse_with(json ?? "", outcome_schema);
-}
-function cited_outcome(record, comment) {
-  const url = record.url ?? comment.html_url;
-  return url === void 0 || !evidence_of(comment, url) ? void 0 : { summary: record.summary, url };
-}
-function outcome_of(comment) {
-  if (comment.is_trusted !== true) return void 0;
-  const record = record_of(comment.body);
-  return record === void 0 ? void 0 : cited_outcome(record, comment);
-}
-function from_comments(comments, candidates = comments) {
-  const outcomes = candidates.flatMap((comment) => {
-    const outcome = outcome_of(comment);
-    const evidence = comments.find((entry) => entry.html_url === outcome?.url);
-    return outcome === void 0 || evidence?.is_trusted !== true ? [] : [outcome];
-  });
-  return outcomes.at(-1);
-}
-async function read(issue) {
-  try {
-    const json = await git_gh_issue_read.issue_list_comments(
-      String(issue),
-      void 0,
-      void 0,
-      git_gh_issue_read.read_comments_conditionally
-    );
-    const comments = json === void 0 ? void 0 : await issue_read.parse_comments(json);
-    return comments === void 0 ? void 0 : from_comments(comments);
-  } catch {
-    return void 0;
-  }
-}
-async function recorded(issue, is_merged) {
-  if (is_merged) return {};
-  const outcome = await read(issue);
-  return outcome === void 0 ? {} : { outcome };
-}
-var issue_outcome = { body_of, from_comments, read, recorded, summary_schema, url_schema };
-
-export {
-  issue_outcome
-};