@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-OYGNL5RO.js

@@ -0,0 +1,290 @@
+import {
+  lane_implement_rate,
+  split_cap
+} from "./chunk-UJFEMO6X.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  hook_launch
+} from "./chunk-OF4BY4N7.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/agent/codex-hooks.ts
+var CODEX_EDIT_TOOL = "apply_patch|functions.apply_patch";
+var CODEX_SHELL_TOOLS = "exec_command|functions.exec_command|exec|functions.exec";
+var TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+var UNMATCHED_EVENTS = /* @__PURE__ */ new Set(["UserPromptSubmit"]);
+var JSON_INDENT = "	";
+var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
+var CODEX_HOOKS_FILE = ".codex/hooks.json";
+var GENERATED_SOURCES = /* @__PURE__ */ new Map([
+  [CODEX_HOOKS_FILE, CLAUDE_SETTINGS_FILE]
+]);
+function adapter_command(mode) {
+  return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`, hook_launch.CODEX_ROOT);
+}
+var ADAPTED_COMMANDS = /* @__PURE__ */ new Map([
+  [hook_launch.hook_launch_command("pretool-guard"), adapter_command("pretool")],
+  [hook_launch.hook_launch_command("format-edited"), adapter_command("posttool")]
+]);
+function codex_handler(handler) {
+  const command = ADAPTED_COMMANDS.get(handler.command) ?? hook_launch.codex_command(handler.command);
+  return { ...handler, command };
+}
+function codex_matcher(event, matcher) {
+  if (UNMATCHED_EVENTS.has(event)) return void 0;
+  if (matcher !== void 0 && TOOL_EVENTS.has(event)) {
+    return `${matcher}|${CODEX_EDIT_TOOL}|${CODEX_SHELL_TOOLS}`;
+  }
+  return matcher;
+}
+function codex_group(event, group) {
+  const matcher = codex_matcher(event, group.matcher);
+  const hooks = group.hooks.map((handler) => codex_handler(handler));
+  return matcher === void 0 ? { hooks } : { matcher, hooks };
+}
+function codex_hook_config(claude) {
+  const events = Object.entries(claude.hooks).map(([event, groups]) => [
+    event,
+    groups.map((group) => codex_group(event, group))
+  ]);
+  return { hooks: Object.fromEntries(events) };
+}
+function codex_hooks_text(claude_settings_text) {
+  const claude = JSON.parse(claude_settings_text);
+  return `${JSON.stringify(codex_hook_config(claude), void 0, JSON_INDENT)}
+`;
+}
+var codex_hooks = {
+  adapter_command,
+  codex_hook_config,
+  codex_hooks_text,
+  CLAUDE_SETTINGS_FILE,
+  CODEX_HOOKS_FILE,
+  GENERATED_SOURCES
+};
+
+// scripts/git/git-path-quoting.ts
+var OCTAL_RADIX = 8;
+var OCTAL_WIDTH = 3;
+var SPACE_CODE = 32;
+var DELETE_CODE = 127;
+var ESCAPES = /* @__PURE__ */ new Map([
+  ["\x07", "a"],
+  ["\b", "b"],
+  ["	", "t"],
+  ["\n", "n"],
+  ["\v", "v"],
+  ["\f", "f"],
+  ["\r", "r"],
+  ['"', '"'],
+  ["\\", "\\"]
+]);
+function escape_character(character) {
+  const short = ESCAPES.get(character);
+  if (short !== void 0) return `\\${short}`;
+  const code = character.codePointAt(0) ?? 0;
+  return code === DELETE_CODE || code < SPACE_CODE ? `\\${code.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, "0")}` : character;
+}
+function quote(file) {
+  const escaped = Array.from(file, (character) => escape_character(character)).join("");
+  return escaped === file ? file : `"${escaped}"`;
+}
+function unescape_character(escaped) {
+  return [...ESCAPES].find((entry) => entry[1] === escaped)?.[0] ?? String.fromCodePoint(Number.parseInt(escaped, OCTAL_RADIX));
+}
+function unquote(file) {
+  if (!file.startsWith('"') || !file.endsWith('"')) return file;
+  return file.slice(1, -1).replaceAll(
+    /\\([0-7]{3}|a|b|f|n|r|t|v|["\\])/gu,
+    (_match, escaped) => unescape_character(escaped)
+  );
+}
+var git_path_quoting = { quote, unquote };
+
+// scripts/split/declared-growth.ts
+var FALLBACK = 2;
+function factor(ratios, axis) {
+  return ratios?.[axis] ?? FALLBACK;
+}
+function axis_text(ratios, axis) {
+  const source = ratios?.[axis] === void 0 ? "fallback" : "measured";
+  return `${axis} \xD7 ${String(factor(ratios, axis))} (${source})`;
+}
+function text(ratios) {
+  return `growth ${axis_text(ratios, "files")} / ${axis_text(ratios, "lines")}`;
+}
+var declared_growth = { FALLBACK, factor, text };
+
+// scripts/split/split-assess.ts
+var { CAP_FACTOR, DEFAULT_CAP, FILE_CAP, FILE_GUIDE, LINE_CAP, LINE_GUIDE } = split_cap;
+var DEFAULT_GUIDE = { files: FILE_GUIDE, lines: LINE_GUIDE, cap: DEFAULT_CAP };
+function guide_for(minutes, measured, growth) {
+  const lines = lane_implement_rate.lines_for(minutes, measured);
+  const correction = growth === void 0 ? {} : { growth };
+  if (lines === void 0 || lines <= LINE_GUIDE) return { ...DEFAULT_GUIDE, ...correction };
+  const files = lines * FILE_GUIDE / LINE_GUIDE;
+  return {
+    files,
+    lines,
+    cap: { files: files * CAP_FACTOR, lines: lines * CAP_FACTOR },
+    ...correction
+  };
+}
+var DECLARED_GROWTH_FACTOR = declared_growth.FALLBACK;
+var SPLIT_VERDICT = "split";
+var SINGLE_VERDICT = "single";
+var SCRIPTS_DIRECTORY = "scripts/";
+var TYPESCRIPT = ".ts";
+var BINARY_MARKER = "-";
+var NUMSTAT_FIELDS = 3;
+function parse_count(field) {
+  if (field === void 0 || field === BINARY_MARKER) return 0;
+  const value = Number(field);
+  return Number.isNaN(value) ? 0 : value;
+}
+function parse_row(row) {
+  const fields = row.split("	");
+  if (fields.length < NUMSTAT_FIELDS) return void 0;
+  const [added, deleted, ...path_parts] = fields;
+  return { path: path_parts.join("	"), changed_lines: parse_count(added) + parse_count(deleted) };
+}
+function parse_numstat(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((row) => parse_row(row)).filter((change) => change !== void 0);
+}
+function is_deliverable(change) {
+  const file = git_path_quoting.unquote(change.path);
+  return !test_declared_logic.is_test_file(file) && !run_record_path.is_run_record(file);
+}
+function is_scripts_module(file) {
+  return file.startsWith(SCRIPTS_DIRECTORY) && file.endsWith(TYPESCRIPT);
+}
+function directory_of(file) {
+  return file.slice(0, file.lastIndexOf("/") + 1);
+}
+function partners_of(files, added) {
+  const modules = files.filter((file) => is_scripts_module(file));
+  const partners = /* @__PURE__ */ new Map();
+  const new_modules = modules.filter((file) => added.has(file));
+  for (const module of new_modules) {
+    const importer = modules.find(
+      (file) => !added.has(file) && !partners.has(file) && directory_of(file) === directory_of(module)
+    );
+    if (importer !== void 0) partners.set(module, importer).set(importer, module);
+  }
+  return partners;
+}
+function units_of(files, added) {
+  const artifacts = codex_hooks.GENERATED_SOURCES;
+  const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
+  const partners = partners_of(sources, added);
+  return sources.flatMap((file) => {
+    const partner = partners.get(file);
+    const unit = partner === void 0 ? [file] : [file, partner];
+    const generated = files.filter((path) => unit.includes(artifacts.get(path) ?? ""));
+    return partner !== void 0 && sources.indexOf(partner) < sources.indexOf(file) ? [] : [[...unit, ...generated]];
+  });
+}
+function verdict_for(files, lines, guide = DEFAULT_GUIDE) {
+  return files > guide.files || lines > guide.lines ? SPLIT_VERDICT : SINGLE_VERDICT;
+}
+function is_over_cap(files, lines, guide = DEFAULT_GUIDE) {
+  return split_cap.is_over(files, lines, guide.cap);
+}
+function measure(changes, guide, added = /* @__PURE__ */ new Set()) {
+  const runtime = changes.filter((change) => is_deliverable(change));
+  const lines = runtime.reduce((total, change) => total + change.changed_lines, 0);
+  const paths = runtime.map((change) => git_path_quoting.unquote(change.path));
+  const files = units_of(paths, added).length;
+  return {
+    files,
+    lines,
+    verdict: verdict_for(files, lines, guide),
+    ...guide !== void 0 && { guide }
+  };
+}
+function assess(raw, guide, added) {
+  return measure(parse_numstat(raw), guide, added);
+}
+var SPLIT_TAIL = "over the guide \u2014 the size condition for a split is met (separability is a separate judgement)";
+var SINGLE_TAIL = "under the guide on both axes \u2014 one Issue, however separable";
+function counted(measurement) {
+  return `${String(measurement.files)} changed file(s), ${String(measurement.lines)} changed line(s), tests excluded`;
+}
+function guide_text(guide) {
+  return `guide ${String(guide.files)} files / ${String(guide.lines)} lines`;
+}
+function policy_text(guide) {
+  const source = guide.lines > LINE_GUIDE ? "measured" : "fallback";
+  return `${guide_text(guide)} (${source}); ${declared_growth.text(guide.growth)}`;
+}
+function reason(measurement, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const tail = measurement.verdict === SPLIT_VERDICT ? SPLIT_TAIL : SINGLE_TAIL;
+  return `${counted(measurement)} (${policy_text(guide)}) \u2014 ${tail}`;
+}
+function grown_bar(declared, guide) {
+  const grown_files = declared.files * declared_growth.factor(guide.growth, "files");
+  const grown_lines = declared.lines * declared_growth.factor(guide.growth, "lines");
+  const files = Math.min(grown_files, guide.files);
+  const lines = Math.min(grown_lines, guide.lines);
+  const capped = files < grown_files || lines < grown_lines ? ", capped at the guide" : "";
+  const declaration = `declared ${String(declared.files)} files / ${String(declared.lines)} lines`;
+  return {
+    files,
+    lines,
+    text: `${declaration}; ${declared_growth.text(guide.growth)}${capped} = ${String(files)} files / ${String(lines)} lines`
+  };
+}
+function is_sized(declared) {
+  return declared !== void 0 && declared.files > 0 && declared.lines > 0;
+}
+function notice_bar(declared, guide) {
+  const guide_bar = { files: guide.files, lines: guide.lines, text: guide_text(guide) };
+  if (!is_sized(declared)) return guide_bar;
+  const bar = grown_bar(declared, guide);
+  return bar.files === guide.files && bar.lines === guide.lines ? guide_bar : bar;
+}
+var NOTICE_SECTION = "Over the guide before the gate";
+var QUESTION_SECTION = "The question";
+var REASON_PREFIX = issue_body_keys.prefix("no_split_reason");
+var NOTICE_ACTION = `go on to the end; a started Issue is never split, and the merge records an overrun past the cap as a pre-split miss \u2014 split-assessment.md \u2192 "${NOTICE_SECTION}"`;
+function notice(measurement, declared, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const bar = notice_bar(declared, guide);
+  if (measurement.files <= bar.files && measurement.lines <= bar.lines) return void 0;
+  return `split notice: ${counted(measurement)} (${bar.text}; ${policy_text(guide)}) \u2014 over the bar, a warning, not a stop: ${NOTICE_ACTION}`;
+}
+var split_assess = {
+  DECLARED_GROWTH_FACTOR,
+  FILE_CAP,
+  FILE_GUIDE,
+  LINE_CAP,
+  LINE_GUIDE,
+  NOTICE_SECTION,
+  QUESTION_SECTION,
+  REASON_PREFIX,
+  SPLIT_VERDICT,
+  SINGLE_VERDICT,
+  assess,
+  guide_for,
+  is_deliverable,
+  is_over_cap,
+  notice,
+  measure,
+  parse_numstat,
+  policy_text,
+  reason,
+  units_of,
+  verdict_for
+};
+
+export {
+  declared_growth,
+  git_path_quoting,
+  split_assess
+};

package/dist/commands/chunk-OYZP5ANC.js

@@ -0,0 +1,48 @@
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lib/figure-format.ts
+var USD_DECIMALS = 4;
+var PERCENT_SCALE = 100;
+var PERCENT_DECIMALS = 1;
+var MINUTE_DECIMALS = 1;
+var CLOCK_WIDTH = 2;
+var CLOCK_PAD = "0";
+function format_usd(usd, decimals = USD_DECIMALS) {
+  return `$${usd.toFixed(decimals)}`;
+}
+function format_tokens(count) {
+  return count.toLocaleString("en-US");
+}
+function format_share(part, whole) {
+  if (whole === 0) return "n/a";
+  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
+}
+function format_minutes(duration_ms) {
+  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
+}
+function two_digits(value) {
+  return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD);
+}
+function clock_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((value) => two_digits(value)).join(":");
+}
+function minute_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(":");
+}
+var figure_format = {
+  format_usd,
+  format_tokens,
+  format_share,
+  format_minutes,
+  two_digits,
+  clock_of,
+  minute_of
+};
+
+export {
+  figure_format
+};

package/dist/commands/chunk-P35FFJXA.js

@@ -0,0 +1,73 @@
+import {
+  start_exec
+} from "./chunk-5VUHAXPI.js";
+import {
+  git_location_environment,
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+
+// scripts/init/working-tree.ts
+var UNTRACKED_ARGUMENTS = ["ls-files", "--others", "--exclude-standard"];
+var MODIFIED_ARGUMENTS = ["diff", "--name-only", "--relative", "HEAD"];
+var INDEXED_ARGUMENTS = ["ls-files", "--cached"];
+var HISTORY_ARGUMENTS = ["rev-list", "--max-count=1", "--all"];
+var UNBORN_HEAD_EXIT_CODE = 1;
+var NOT_A_REPOSITORY = "not a git repository";
+function paths_of(output = "") {
+  return output.split("\0").filter((listed) => listed.length > 0);
+}
+function listing(args, root) {
+  return paths_of(start_exec.git_read([...args, "-z"], root));
+}
+function changed_paths(root) {
+  const untracked = listing(UNTRACKED_ARGUMENTS, root);
+  const modified = listing(MODIFIED_ARGUMENTS, root);
+  return [...untracked, ...modified];
+}
+function strict_listing(args, root) {
+  const output = start_exec.git_read([...args, "-z"], root);
+  if (output === void 0) throw new Error(`git ${args.join(" ")} failed in ${root}`);
+  return paths_of(output);
+}
+function head_state(root) {
+  const { exit_code, stderr } = git_spawn_sync.run(["rev-parse", "--verify", "--quiet", "HEAD"], {
+    cwd: root,
+    env: { ...git_spawn_sync.C_LOCALE, ...git_location_environment.location_free_environment() }
+  });
+  if (exit_code === 0) return "born";
+  if (stderr.includes(NOT_A_REPOSITORY)) return "absent";
+  if (exit_code === UNBORN_HEAD_EXIT_CODE) return "unborn";
+  throw new Error(`git rev-parse could not read HEAD in ${root}`);
+}
+function has_history(root) {
+  const output = start_exec.git_read(HISTORY_ARGUMENTS, root);
+  if (output === void 0) throw new Error(`git ${HISTORY_ARGUMENTS.join(" ")} failed in ${root}`);
+  return output.trim().length > 0;
+}
+function tracked_arguments(root) {
+  const state = head_state(root);
+  if (state === "born") return MODIFIED_ARGUMENTS;
+  if (state === "unborn" && has_history(root)) return INDEXED_ARGUMENTS;
+  return void 0;
+}
+function uncommitted_paths(root) {
+  const tracked = tracked_arguments(root);
+  if (tracked === void 0) return [];
+  const untracked = strict_listing(UNTRACKED_ARGUMENTS, root);
+  const modified = strict_listing(tracked, root);
+  return [...untracked, ...modified];
+}
+function dirty_tree_refusal(root, command) {
+  const paths = uncommitted_paths(root);
+  if (paths.length === 0) return void 0;
+  return [
+    `${command} refuses to run: the working tree has uncommitted changes.`,
+    ...paths.map((listed) => `  ${listed}`),
+    `Commit them, or stash them with \`git stash push -u -- .\`, then run ${command} again.`
+  ].join("\n");
+}
+var working_tree = { listing, changed_paths, uncommitted_paths, dirty_tree_refusal };
+
+export {
+  working_tree
+};

package/dist/commands/chunk-P3UODIMZ.js

@@ -0,0 +1,272 @@
+import {
+  repo_setting
+} from "./chunk-VBZ47BVH.js";
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  gh_failure,
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/repo/required-checks-report.ts
+var LABEL = "Required status checks";
+var APPLY_COMMAND = "pnpm josh ruleset:check --apply";
+function source_label(source) {
+  return source.kind === "ruleset" ? `ruleset ${String(source.ruleset_id)}` : "branch protection";
+}
+function format_unreadable(report) {
+  return [
+    `  \u26A0 ${LABEL}: could not be read (${repo_setting.report_target(report.repo)}) \u2014 not checked, not necessarily missing`,
+    "    `gh` is missing or unauthenticated, or the request failed (offline, timed out)."
+  ];
+}
+function format_none(report, target) {
+  return [
+    `  \u26A0 ${LABEL}: none required on ${String(report.branch)} (${target})`,
+    `    Expected: ${report.expected.join(", ")}`,
+    "    Create a branch ruleset (Settings \u2192 Rules \u2192 Rulesets) that requires them."
+  ];
+}
+function format_found(report, target) {
+  const where = `${String(report.branch)} (${target}, ${source_label(report.source)})`;
+  if (report.missing.length === 0) {
+    return [`  \u2714 ${LABEL}: all ${String(report.expected.length)} kit checks required on ${where}`];
+  }
+  return [
+    `  \u26A0 ${LABEL}: ${report.missing.join(", ")} not required on ${where}`,
+    `    Add: ${APPLY_COMMAND}`
+  ];
+}
+function format_report(report) {
+  const target = repo_setting.report_target(report.repo);
+  if (report.source.kind === "unreadable") return format_unreadable(report);
+  if (report.source.kind === "none") return format_none(report, target);
+  return format_found(report, target);
+}
+function is_complete(report) {
+  const is_read = report.source.kind === "ruleset" || report.source.kind === "protection";
+  return is_read && report.missing.length === 0;
+}
+var required_checks_report = { format_report, is_complete };
+
+// scripts/repo/ruleset-check.ts
+import path from "node:path";
+
+// scripts/repo/required-checks-logic.ts
+import { z } from "zod";
+var CI_WORKFLOW = ".github/workflows/ci.yml";
+var SONAR_WORKFLOW = ".github/workflows/sonar-qube.yml";
+var CLASSIFICATION_WORKFLOW = ".github/workflows/pr-classification.yml";
+var REQUIRED_STATUS_CHECKS = "required_status_checks";
+var NOT_FOUND_STATUS = 404;
+var DISTRIBUTED_CHECKS = [
+  {
+    workflow: CI_WORKFLOW,
+    checks: ["Checks", "Detect E2E", "E2E", "Secret Scan", "Security Audit"]
+  },
+  { workflow: SONAR_WORKFLOW, checks: ["SonarQube"] },
+  { workflow: CLASSIFICATION_WORKFLOW, checks: ["Release classification"] }
+];
+var status_check_schema = z.looseObject({ context: z.string() });
+var branch_rule_schema = z.looseObject({
+  type: z.literal(REQUIRED_STATUS_CHECKS),
+  ruleset_id: z.number(),
+  parameters: z.looseObject({ required_status_checks: z.array(status_check_schema) })
+});
+var protection_schema = z.looseObject({ contexts: z.array(z.string()) });
+var ruleset_rule_schema = z.looseObject({
+  type: z.string(),
+  parameters: z.looseObject({ required_status_checks: z.array(status_check_schema).optional() }).optional()
+});
+var ruleset_schema = z.looseObject({ rules: z.array(ruleset_rule_schema) });
+var workflow_job_schema = z.looseObject({ name: z.string().optional() });
+var workflow_schema = z.looseObject({ jobs: z.record(z.string(), workflow_job_schema) });
+function parse_yaml_safe(content) {
+  try {
+    return yaml_document.parse_yaml(content);
+  } catch {
+    return void 0;
+  }
+}
+function workflow_job_names(content) {
+  const parsed = workflow_schema.safeParse(parse_yaml_safe(content));
+  if (!parsed.success) return [];
+  return Object.values(parsed.data.jobs).flatMap((job) => job.name ?? []);
+}
+function expected_checks(read_workflow) {
+  return DISTRIBUTED_CHECKS.flatMap((entry) => {
+    const content = read_workflow(entry.workflow);
+    if (content === void 0) return [];
+    const reported = workflow_job_names(content);
+    return entry.checks.filter((check) => reported.includes(check));
+  });
+}
+function status_check_rules(payload) {
+  return payload.flatMap((entry) => {
+    const parsed = branch_rule_schema.safeParse(entry);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function parse_branch_rules(stdout) {
+  const payload = stdout === void 0 ? void 0 : json_value.parse_array(stdout);
+  if (payload === void 0) return { kind: "unreadable" };
+  const rules = status_check_rules(payload);
+  const [first] = rules;
+  if (first === void 0) return { kind: "none" };
+  const contexts = rules.flatMap(
+    (rule) => rule.parameters.required_status_checks.map((check) => check.context)
+  );
+  return { kind: "ruleset", ruleset_id: first.ruleset_id, contexts };
+}
+function parse_protection(read) {
+  if (read.kind === "failed") {
+    return { kind: read.status === NOT_FOUND_STATUS ? "none" : "unreadable" };
+  }
+  const parsed = protection_schema.safeParse(json_value.parse_or_undefined(read.stdout));
+  return parsed.success ? { kind: "protection", contexts: parsed.data.contexts } : { kind: "unreadable" };
+}
+function combine_sources(rules, protection) {
+  if (rules.kind !== "ruleset") return protection;
+  if (protection.kind === "none") return rules;
+  if (protection.kind !== "protection") return { kind: "unreadable" };
+  return { ...rules, contexts: [.../* @__PURE__ */ new Set([...rules.contexts, ...protection.contexts])] };
+}
+function missing_checks(expected, contexts) {
+  return expected.filter((check) => !contexts.includes(check));
+}
+function with_added_checks(rule, missing) {
+  if (rule.type !== REQUIRED_STATUS_CHECKS || rule.parameters === void 0) return rule;
+  const current = rule.parameters.required_status_checks ?? [];
+  const added = missing.map((context) => ({ context }));
+  return {
+    ...rule,
+    parameters: { ...rule.parameters, required_status_checks: [...current, ...added] }
+  };
+}
+function ruleset_update_body(ruleset_stdout, missing) {
+  const parsed = ruleset_schema.safeParse(json_value.parse_or_undefined(ruleset_stdout));
+  if (!parsed.success) return void 0;
+  return JSON.stringify({
+    rules: parsed.data.rules.map((rule) => with_added_checks(rule, missing))
+  });
+}
+function protection_update_body(missing) {
+  return JSON.stringify({ contexts: missing });
+}
+var required_checks_logic = {
+  DISTRIBUTED_CHECKS,
+  workflow_job_names,
+  expected_checks,
+  parse_branch_rules,
+  parse_protection,
+  combine_sources,
+  missing_checks,
+  ruleset_update_body,
+  protection_update_body
+};
+
+// scripts/repo/ruleset-check.ts
+function read_api(api_path) {
+  return git_gh_exec.read_gh_api_sync({
+    path: api_path,
+    cwd: PROJECT_ROOT,
+    timeout_ms: repo_setting.GH_TIMEOUT_MS
+  });
+}
+function read_default_branch(repo) {
+  const branch = git_gh_exec.read_gh_api_sync({
+    path: `repos/${repo}`,
+    jq_filter: ".default_branch",
+    cwd: PROJECT_ROOT,
+    timeout_ms: repo_setting.GH_TIMEOUT_MS
+  })?.trim();
+  return branch === "" ? void 0 : branch;
+}
+function read_protection(repo, branch) {
+  try {
+    const stdout = git_gh_exec.exec_gh_api_sync({
+      path: git_gh_api_path.branch_protection_checks_api_path(branch, repo),
+      cwd: PROJECT_ROOT,
+      timeout_ms: repo_setting.GH_TIMEOUT_MS
+    });
+    return { kind: "body", stdout };
+  } catch (error) {
+    return { kind: "failed", status: gh_failure.failure_of(error)?.status };
+  }
+}
+function read_source(repo, branch) {
+  const from_rules = required_checks_logic.parse_branch_rules(
+    read_api(git_gh_api_path.branch_rules_api_path(branch, repo))
+  );
+  if (from_rules.kind === "unreadable") return from_rules;
+  const from_protection = required_checks_logic.parse_protection(read_protection(repo, branch));
+  return required_checks_logic.combine_sources(from_rules, from_protection);
+}
+function expected_in(root) {
+  return required_checks_logic.expected_checks(
+    (workflow) => file_reader.read_if_readable(path.join(root, workflow))
+  );
+}
+function contexts_of(source) {
+  return source.kind === "ruleset" || source.kind === "protection" ? source.contexts : [];
+}
+function inspect(repo, root) {
+  const expected = expected_in(root);
+  const branch = repo === void 0 ? void 0 : read_default_branch(repo);
+  const source = repo === void 0 || branch === void 0 ? { kind: "unreadable" } : read_source(repo, branch);
+  const missing = source.kind === "unreadable" ? [] : required_checks_logic.missing_checks(expected, contexts_of(source));
+  return { repo, branch, source, expected, missing };
+}
+function apply_to_ruleset(repo, ruleset_id, missing) {
+  const api_path = `repos/${repo}/rulesets/${String(ruleset_id)}`;
+  const current = git_gh_exec.exec_gh_api_sync({ path: api_path, cwd: PROJECT_ROOT });
+  const body = required_checks_logic.ruleset_update_body(current, missing);
+  if (body === void 0) throw new Error(`Unexpected ruleset response from ${api_path}`);
+  git_gh_exec.exec_gh_api_sync({ path: api_path, method: "PUT", body, cwd: PROJECT_ROOT });
+}
+function apply_to_protection(repo, branch, missing) {
+  git_gh_exec.exec_gh_api_sync({
+    path: `${git_gh_api_path.branch_protection_checks_api_path(branch, repo)}/contexts`,
+    method: "POST",
+    body: required_checks_logic.protection_update_body(missing),
+    cwd: PROJECT_ROOT
+  });
+}
+function apply_to_source(repo, branch, source, missing) {
+  if (source.kind === "ruleset") {
+    apply_to_ruleset(repo, source.ruleset_id, missing);
+    return true;
+  }
+  if (source.kind !== "protection") return false;
+  apply_to_protection(repo, branch, missing);
+  return true;
+}
+function apply_missing(report) {
+  const { repo, branch, source, missing } = report;
+  if (repo === void 0 || branch === void 0 || missing.length === 0) return false;
+  return apply_to_source(repo, branch, source, missing);
+}
+function report_required_checks_section(repo, root) {
+  const report = inspect(repo, root);
+  repo_setting.print_section(required_checks_report.format_report(report));
+  return report;
+}
+var ruleset_check = { expected_in, inspect, apply_missing, report_required_checks_section };
+
+export {
+  required_checks_report,
+  ruleset_check
+};