@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-BHRS7HAM.js

@@ -1,272 +0,0 @@
-import {
-  repo_setting
-} from "./chunk-JJRKTWLK.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-XDF25GSU.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
-};

package/dist/commands/chunk-BIKGPT52.js

@@ -1,29 +0,0 @@
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-
-// scripts/version/latest-lane-guard.ts
-var STAMP_NOTE = "the josh latest stamp is keyed to the project root, so a fresh lane has no record and always reads as stale";
-var PRIMARY_NOTE = "run josh latest in the primary checkout, never in a lane";
-var LANE_SCOPE_REASON = `inside a lane \u2014 ${STAMP_NOTE}; ${PRIMARY_NOTE}`;
-var LANE_REFUSAL = `josh latest is refused inside a lane \u2014 ${STAMP_NOTE}; ${PRIMARY_NOTE}`;
-var REFUSAL_EXIT_CODE = 1;
-function is_lane(cwd = process.cwd(), environment = process.env) {
-  return lane_paths.lane_issue_of(cwd, environment) !== void 0;
-}
-function main() {
-  if (!is_lane()) return;
-  console.error(LANE_REFUSAL);
-  process.exitCode = REFUSAL_EXIT_CODE;
-}
-var latest_lane_guard = {
-  LANE_REFUSAL,
-  LANE_SCOPE_REASON,
-  REFUSAL_EXIT_CODE,
-  is_lane,
-  main
-};
-
-export {
-  latest_lane_guard
-};

package/dist/commands/chunk-BJA5U4Q7.js

@@ -1,75 +0,0 @@
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-
-// scripts/lane/lane-hand-back-hold.ts
-import {
-  closeSync,
-  constants,
-  openSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeSync
-} from "node:fs";
-var MARK_SUFFIX = ".hand-back";
-var MARK_FILE_MODE = 384;
-var MARK_ENCODING = "utf8";
-var { O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = constants;
-var WRITE_FLAGS = O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW;
-function mark_of(ledger) {
-  return `${ledger}${MARK_SUFFIX}`;
-}
-async function destination(ledger) {
-  const resolved = ledger ?? await lane_ledger_write.target();
-  return resolved === void 0 ? void 0 : mark_of(resolved);
-}
-function write(path, reason) {
-  const descriptor = openSync(path, WRITE_FLAGS, MARK_FILE_MODE);
-  try {
-    writeSync(descriptor, reason);
-  } finally {
-    closeSync(descriptor);
-  }
-}
-async function mark(reason, ledger) {
-  try {
-    const path = await destination(ledger);
-    if (path !== void 0) write(path, reason);
-  } catch {
-  }
-}
-async function clear(ledger) {
-  try {
-    const path = await destination(ledger);
-    if (path !== void 0) rmSync(path, { force: true });
-  } catch {
-  }
-}
-function read(ledger) {
-  try {
-    return readFileSync(mark_of(ledger), MARK_ENCODING);
-  } catch {
-    return void 0;
-  }
-}
-function take(ledger) {
-  const taken = `${mark_of(ledger)}.${String(process.pid)}`;
-  try {
-    renameSync(mark_of(ledger), taken);
-  } catch {
-    return void 0;
-  }
-  try {
-    return readFileSync(taken, MARK_ENCODING);
-  } catch {
-    return void 0;
-  } finally {
-    rmSync(taken, { force: true });
-  }
-}
-var lane_hand_back_hold = { clear, mark, read, take };
-
-export {
-  lane_hand_back_hold
-};

package/dist/commands/chunk-BMKWSWWE.js

@@ -1,126 +0,0 @@
-import {
-  review_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-
-// scripts/review/review-round-one-blobs.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-var ABSENT = review_tree.ABSENT_DIGEST;
-var SUCCESS_EXIT_CODE = 0;
-var NUL = "\0";
-var NEWLINE = "\n";
-var TAB = "	";
-var SPACE = " ";
-var OID_FIELD = 2;
-var WRITE_FLAGS = ["-w"];
-var READ_FLAGS = [];
-function repository_root() {
-  return git_spawn_sync.read(["rev-parse", "--show-toplevel"]);
-}
-function hash_paths(root, paths, flags) {
-  const present = paths.filter((relative) => existsSync(path.join(root, relative)));
-  const output = present.length === 0 ? "" : git_spawn_sync.read(["hash-object", ...flags, "--", ...present], { cwd: root });
-  if (output === void 0) return void 0;
-  const hashes = output.split(NEWLINE);
-  const hashed = new Map(present.map((relative, index) => [relative, hashes[index] ?? ABSENT]));
-  return Object.fromEntries(paths.map((relative) => [relative, hashed.get(relative) ?? ABSENT]));
-}
-function parse_entry(entry) {
-  const tab = entry.indexOf(TAB);
-  return [entry.slice(tab + 1), entry.slice(0, tab).split(SPACE)[OID_FIELD] ?? ABSENT];
-}
-function blobs_at(commit, paths, root) {
-  const result = git_spawn_sync.run(["ls-tree", "-r", "-z", commit, "--", ...paths], { cwd: root });
-  if (result.exit_code !== SUCCESS_EXIT_CODE) return void 0;
-  return Object.fromEntries(
-    result.stdout.split(NUL).filter((entry) => entry !== "").map((entry) => parse_entry(entry))
-  );
-}
-function merged_blob({ base, round_one, moved }, root) {
-  if ([base, round_one, moved].includes(ABSENT)) return void 0;
-  return git_spawn_sync.read(["merge-file", "--object-id", round_one, base, moved], { cwd: root });
-}
-function carried_blob(sides, root) {
-  if (sides.round_one === sides.base) return sides.moved;
-  if (sides.moved === sides.base || sides.moved === sides.round_one) return sides.round_one;
-  return merged_blob(sides, root);
-}
-function sides_of(relative, readings) {
-  const base = readings.before[relative] ?? ABSENT;
-  return {
-    base,
-    round_one: readings.blobs[relative] ?? base,
-    moved: readings.after[relative] ?? ABSENT
-  };
-}
-function carried_answer(relative, readings, root) {
-  const carried = carried_blob(sides_of(relative, readings), root);
-  return carried === void 0 ? void 0 : carried === readings.now[relative];
-}
-function differing(paths, readings, root) {
-  const answers = paths.map((relative) => carried_answer(relative, readings, root));
-  if (answers.includes(void 0)) return void 0;
-  return paths.filter((_relative, index) => answers[index] === false);
-}
-function read_readings(input, paths, root) {
-  const before = blobs_at(input.from, paths, root);
-  const after = blobs_at(input.to, paths, root);
-  const now = hash_paths(root, paths, READ_FLAGS);
-  if (before === void 0 || after === void 0 || now === void 0) return void 0;
-  return { blobs: input.blobs, before, after, now };
-}
-function delta_of(input, root) {
-  const paths = [.../* @__PURE__ */ new Set([...Object.keys(input.blobs), ...input.paths])].toSorted(
-    (left, right) => left.localeCompare(right)
-  );
-  const readings = paths.length === 0 ? void 0 : read_readings(input, paths, root);
-  if (paths.length === 0) return [];
-  return readings === void 0 ? void 0 : differing(paths, readings, root);
-}
-function carry_of({ blobs, from, to, paths }) {
-  if (blobs === void 0 || from === void 0 || to === void 0) return void 0;
-  return { blobs, from, to, paths };
-}
-function carried_delta(input) {
-  const carry = carry_of(input);
-  const root = repository_root();
-  return carry === void 0 || root === void 0 ? void 0 : delta_of(carry, root);
-}
-function answers_of(carry, root) {
-  const { paths } = carry;
-  const readings = paths.length === 0 ? void 0 : read_readings(carry, paths, root);
-  if (paths.length === 0) return {};
-  if (readings === void 0) return void 0;
-  return Object.fromEntries(
-    paths.map((relative) => [relative, carried_answer(relative, readings, root)])
-  );
-}
-function carried_each(input) {
-  const carry = carry_of(input);
-  const root = repository_root();
-  return carry === void 0 || root === void 0 ? void 0 : answers_of(carry, root);
-}
-function unmoved_between(from, to, paths, root) {
-  if (from === to || paths.length === 0) return paths;
-  const before = blobs_at(from, paths, root);
-  const after = blobs_at(to, paths, root);
-  if (before === void 0 || after === void 0) return void 0;
-  return paths.filter((relative) => (before[relative] ?? ABSENT) === (after[relative] ?? ABSENT));
-}
-function unmoved({ from, to, paths }) {
-  const root = repository_root();
-  if (root === void 0 || from === void 0 || to === void 0) return void 0;
-  return unmoved_between(from, to, paths, root);
-}
-function capture(paths) {
-  const root = repository_root();
-  return root === void 0 ? void 0 : hash_paths(root, paths, WRITE_FLAGS);
-}
-var review_round_one_blobs = { capture, carried_delta, carried_each, unmoved };
-
-export {
-  review_round_one_blobs
-};

package/dist/commands/chunk-BMTYUJNT.js

@@ -1,59 +0,0 @@
-import {
-  project_checks
-} from "./chunk-JM6EVOFN.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-
-// scripts/gate/structural-checks.ts
-var GUARD_TEST_COMMAND = ["josh", "test:unit", "--passWithNoTests"];
-var STRUCTURAL_GUARD_TARGETS = [
-  "scripts/issue/session-cite-scan.test.ts",
-  "tools/test/untested-sources.test.ts",
-  "tools/gh/gh-subcommand-guard.test.ts"
-];
-var STRUCTURAL_LISTS = [
-  [...GUARD_TEST_COMMAND, ...STRUCTURAL_GUARD_TARGETS]
-];
-var TYPESCRIPT_SUFFIX = ".ts";
-var FAILURE_EXIT_CODE = 1;
-function failure_prefix(list) {
-  return `\u2717 ${list.join(" ")} \u2014 `;
-}
-function failure_heading(list, result) {
-  const ending = result.exit_code === void 0 ? "no exit code (timed out or ended by a signal)" : `exit code ${String(result.exit_code)}`;
-  return `${failure_prefix(list)}${ending}`;
-}
-function failure_section(list, result) {
-  const parts = [failure_heading(list, result), result.output.trim()];
-  return parts.filter((part) => part !== "").join("\n");
-}
-function is_due(scope, root) {
-  if (!project_checks.is_kit_repository(root)) return false;
-  return scope.mode === "all" || scope.files.some((file) => file.endsWith(TYPESCRIPT_SUFFIX));
-}
-async function run_in(root, list) {
-  return { list, result: await buffered_process.run_buffered_process(list, { cwd: root }) };
-}
-async function run_structural(scope, root) {
-  if (!is_due(scope, root)) return 0;
-  const runs = await Promise.all(STRUCTURAL_LISTS.map(async (list) => await run_in(root, list)));
-  const failed = runs.filter(({ result }) => buffered_process.is_process_failed(result));
-  if (failed.length === 0) return 0;
-  const sections = failed.map(({ list, result }) => failure_section(list, result));
-  process.stdout.write(`
-${sections.join("\n\n")}
-`);
-  return FAILURE_EXIT_CODE;
-}
-var structural_checks = {
-  GUARD_TEST_COMMAND,
-  STRUCTURAL_GUARD_TARGETS,
-  failure_prefix,
-  failure_section,
-  run_structural
-};
-
-export {
-  structural_checks
-};

package/dist/commands/chunk-BRHPRDDV.js

@@ -1,127 +0,0 @@
-import {
-  capped_output
-} from "./chunk-2CXT6MBR.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  issue_state
-} from "./chunk-XFPEUYDV.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-
-// scripts/issue/issue-report-failures.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var UNCLASSIFIED_CAUSE = "a rate limit, expired auth, or a dropped connection";
-function print_blocks(blocks, separator, label) {
-  if (blocks.length === 0) return;
-  capped_output.capped_print(blocks.join(separator), label);
-}
-function report_failure(kind, issue_number, misreading, hint) {
-  if (kind === "missing") {
-    console.error(
-      `\u2716 issue ${session_cite.issue(issue_number)} does not resolve \u2014 check the number and the repository`
-    );
-  } else {
-    console.error(
-      `\u2716 could not read issue ${session_cite.issue(issue_number)} \u2014 ${hint ?? UNCLASSIFIED_CAUSE}. This is not "${misreading}"`
-    );
-  }
-}
-function is_failure_kind(kind) {
-  return kind === "missing" || kind === "unreadable";
-}
-function report_one_failure(report, terms) {
-  const { kind, hint } = report.result;
-  if (!is_failure_kind(kind)) return false;
-  report_failure(kind, report.issue_number, terms.misreading, hint);
-  return true;
-}
-function report_failures(reports, terms) {
-  let has_failure = false;
-  for (const report of reports) {
-    has_failure = report_one_failure(report, terms) || has_failure;
-  }
-  return has_failure ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE;
-}
-var issue_report_failures = { print_blocks, report_failures };
-
-// scripts/issue/issue-state-cli.ts
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh issue:state <issue-number> [<issue-number> ...] [--repo <owner/repo>]";
-var BLOCK_SEPARATOR = "\n\n";
-var STATE_FIELDS = "state,labels";
-var FAILURE_TERMS = { success_kind: "state", misreading: "the issue is open" };
-var OPTIONS = { repo: { type: "string", multiple: true } };
-function read_repo(given) {
-  if (given === void 0) return {};
-  const [repo, ...rest] = given;
-  return repo !== void 0 && rest.length === 0 && repo.length > 0 ? { repo } : void 0;
-}
-function is_issue_numbers(positionals) {
-  return positionals.length > 0 && positionals.every((argument) => issue_number_shape.is_issue_number(argument));
-}
-function parse_request(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  if (parsed === void 0) return void 0;
-  const repo = read_repo(parsed.values.repo);
-  if (repo === void 0 || !is_issue_numbers(parsed.positionals)) return void 0;
-  return { issue_numbers: [...new Set(parsed.positionals)], ...repo };
-}
-async function read_issue(issue_number, repo) {
-  const read = await git_gh_command.issue_view_json_classified(issue_number, STATE_FIELDS, repo);
-  if (read.kind !== "read") return read;
-  const parsed = issue_state.parse_issue_state(read.json);
-  return parsed === void 0 ? { kind: "unreadable", reason: "malformed" } : { kind: "state", state: parsed };
-}
-async function read_all(request) {
-  return await Promise.all(
-    request.issue_numbers.map(async (issue_number) => ({
-      issue_number,
-      result: await read_issue(issue_number, request.repo)
-    }))
-  );
-}
-function state_blocks(report, should_attribute) {
-  if (report.result.kind !== "state") return [];
-  const { state } = report.result;
-  if (!should_attribute) return [issue_state.format_issue_state(state)];
-  return [issue_state.format_attributed_issue_state(report.issue_number, state)];
-}
-function print_states(reports) {
-  const should_attribute = reports.length > 1;
-  const blocks = reports.flatMap((report) => state_blocks(report, should_attribute));
-  issue_report_failures.print_blocks(blocks, BLOCK_SEPARATOR, "issue:state");
-}
-async function run(argv) {
-  const request = parse_request(argv);
-  if (request === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const reports = await read_all(request);
-  print_states(reports);
-  return issue_report_failures.report_failures(reports, FAILURE_TERMS);
-}
-var issue_state_cli = {
-  REPO_OPTIONS: OPTIONS,
-  STATE_FIELDS,
-  USAGE,
-  parse_request,
-  read_issue,
-  read_repo,
-  run
-};
-
-export {
-  issue_report_failures,
-  issue_state_cli
-};