@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-5ZMVRU3U.js

@@ -0,0 +1,46 @@
+import {
+  git_command,
+  git_diff_reads
+} from "./chunk-KMED24C4.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-5ZWU2B7T.js

@@ -0,0 +1,507 @@
+import {
+  review_round_one_blobs
+} from "./chunk-6LHMR3CR.js";
+import {
+  review_untouched_readers
+} from "./chunk-7T7GIZYW.js";
+import {
+  review_readers_scan
+} from "./chunk-W6MVQEMO.js";
+import {
+  review_interaction
+} from "./chunk-TGCIRQG5.js";
+import {
+  review_diff_parts
+} from "./chunk-MY3RSOS5.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  removed_tests
+} from "./chunk-ISNZX75X.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-37RULO76.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  review_stop_log
+} from "./chunk-4E5WBWG7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/review/review-round.ts
+var FULL_CHANGE_FLAG = "--full-change";
+var FINAL_LINE = "Review round: 2 \u2014 final, whole change, read only.";
+var SECOND_ROUND = 2;
+var ROUND_ARGUMENT_COUNT = 2;
+var ROUND_PREFIX = "josh-review-round-";
+function numbered_round(argv) {
+  if (argv.length !== ROUND_ARGUMENT_COUNT || argv[0] !== "--round") return void 0;
+  const round = Number(argv[1]);
+  return round === 1 || round === SECOND_ROUND ? round : void 0;
+}
+function parse_round(argv) {
+  if (argv.length === 0) return 1;
+  if (argv.length === 1) return argv[0] === FULL_CHANGE_FLAG ? SECOND_ROUND : void 0;
+  return numbered_round(argv);
+}
+function from_brief(brief, fallback = "1") {
+  return brief.split("\n").includes(FINAL_LINE) ? "2" : fallback;
+}
+function record(round, root) {
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0) return;
+  stamp_file.write_text_stamp(stamp_file.stamp_path(ROUND_PREFIX, pointer.nonce), String(round));
+}
+function current(root) {
+  const pointer = review_attest.read_pointer(root);
+  const text = pointer === void 0 ? void 0 : stamp_file.read_stamp_text(stamp_file.stamp_path(ROUND_PREFIX, pointer.nonce));
+  return text === "2" ? "2" : "1";
+}
+var review_round = {
+  current,
+  from_brief,
+  record,
+  parse_round,
+  FINAL_LINE,
+  FULL_CHANGE_FLAG,
+  SECOND_ROUND
+};
+
+// scripts/review/review-finding-text.ts
+var DESCRIPTION_SEPARATOR = " \u2014 ";
+var DESCRIPTION_BOUNDARY = / [—–-]{1,2} /u;
+var SENTENCE_END = /(?<=[.!?])\s|(?<=。)/u;
+var SENTENCE_LIMIT = 200;
+var ELLIPSIS = "\u2026";
+function split_description(unmarked) {
+  const boundary = DESCRIPTION_BOUNDARY.exec(unmarked);
+  if (boundary === null) return { spec: unmarked.trim(), description: "" };
+  const rest = unmarked.slice(boundary.index + boundary[0].length);
+  return { spec: unmarked.slice(0, boundary.index).trim(), description: rest.trim() };
+}
+function first_sentence(description) {
+  const [sentence = ""] = description.split(SENTENCE_END, 1);
+  if (sentence.length <= SENTENCE_LIMIT) return sentence;
+  return `${sentence.slice(0, SENTENCE_LIMIT - ELLIPSIS.length)}${ELLIPSIS}`;
+}
+var review_finding_text = {
+  DESCRIPTION_SEPARATOR,
+  SENTENCE_LIMIT,
+  first_sentence,
+  split_description
+};
+
+// scripts/review/review-fix-round.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var finding_schema = z.object({
+  category: z.string(),
+  severity: z.string(),
+  file: z.string(),
+  description: z.string(),
+  disposition: z.string().optional()
+});
+var round_schema = z.object({
+  id: z.string(),
+  issue: z.number(),
+  snapshot: z.string(),
+  findings: z.array(finding_schema)
+});
+function target(root) {
+  return stamp_file.stamp_path("josh-review-fix-round-", root);
+}
+function read(root) {
+  const raw = stamp_file.read_stamp_text(target(root)) ?? "";
+  return round_schema.safeParse(json_value.parse_or_undefined(raw)).data;
+}
+function snapshot(round) {
+  try {
+    return file_map_stamp.parse_stamp(round.snapshot);
+  } catch {
+    return void 0;
+  }
+}
+function resume(checkout) {
+  const round = read(checkout.root);
+  const stamp = round === void 0 ? void 0 : snapshot(round);
+  if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, checkout.root)) {
+    return void 0;
+  }
+  return review_attest.is_attested_on(checkout, checkout.root) ? round : void 0;
+}
+function key(finding) {
+  return JSON.stringify([
+    finding.category,
+    finding.file.replace(/:\d+(?:-\d+)?$/u, ""),
+    finding.description
+  ]);
+}
+function correspondence(previous, current2) {
+  const before = previous?.issue === current2.issue ? previous.findings : [];
+  const rows = current2.findings.map((finding) => ({
+    ...finding,
+    status: before.filter((old) => key(old) === key(finding)).length === 1 ? "continuing" : "new"
+  }));
+  const resolved = before.filter(
+    (old) => current2.findings.every((finding) => key(old) !== key(finding))
+  );
+  return [...rows, ...resolved.map((finding) => ({ ...finding, status: "resolved" }))].map(
+    (row) => `- rx:${JSON.stringify({ round: current2.id, previous: previous?.id, ...row, status: review_finding_ledger.is_closing(row.disposition) ? "resolved" : row.status })}`
+  );
+}
+function prepare(issue, findings, root) {
+  const stamp = review_stamps.briefed_stamp.read();
+  if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, root)) return void 0;
+  return {
+    id: randomUUID(),
+    issue,
+    snapshot: JSON.stringify(stamp),
+    findings: findings.map((finding) => ({ ...finding, description: finding.description ?? "" }))
+  };
+}
+function save(round, root) {
+  stamp_file.write_stamp(target(root), round);
+}
+function lines(round, root) {
+  return round === void 0 ? [] : correspondence(read(root), round);
+}
+function record_reasons(issue, findings) {
+  review_stop_log.record({
+    issue,
+    stage: "review:record",
+    is_fixed: true,
+    findings: findings.filter((finding) => (finding.description ?? "").length > 0).map((finding) => ({
+      kind: `${finding.category}:${finding.severity}`,
+      location: finding.file,
+      sentence: review_finding_text.first_sentence(finding.description ?? "")
+    }))
+  });
+}
+var review_fix_round = {
+  correspondence,
+  lines,
+  prepare,
+  read,
+  record_reasons,
+  resume,
+  save,
+  snapshot
+};
+
+// scripts/review/review-brief-paths.ts
+function format_paths(root, paths) {
+  return paths.map((relative) => `  ${root}/${relative}`).join("\n");
+}
+var HIGH_FIX_LINE = "These files hold the fix of a High round 1 recorded \u2014 read each whole, not only its hunks, with the fix sites the finding names:";
+function high_fix_lines(root, cited2 = []) {
+  return cited2.length === 0 ? [] : [`${HIGH_FIX_LINE}
+${format_paths(root, cited2)}`];
+}
+var review_brief_paths = { format_paths, HIGH_FIX_LINE, high_fix_lines };
+
+// scripts/review/review-fix-hunks.ts
+var LOCATION = /^(?<path>.+):(?<start>\d+)(?:-(?<end>\d+))?$/u;
+var RESUMED_HEADING = "Resumed round 1 \u2014 a review of this branch was already attested, so this pass reads only what changed since the tree it read.";
+function resumed_block(input) {
+  if (input.recorded_at === void 0 || input.paths === "") return input.fallback;
+  return [
+    RESUMED_HEADING,
+    `The attested review read the tree recorded at ${input.recorded_at}.`,
+    `Target: only these files, which changed since that tree:
+${input.paths}`,
+    ...input.reconciliation,
+    "Review these files in full against the rubric \u2014 they are the only code this pass has not already read."
+  ].join("\n");
+}
+function covers(start, end, line) {
+  return line >= Number(start) && line <= Number(end ?? start);
+}
+function cited(finding, file, line) {
+  const groups = LOCATION.exec(finding.file)?.groups;
+  if (groups?.["path"] !== file) return false;
+  return covers(groups["start"] ?? "", groups["end"], line);
+}
+function is_blob(value) {
+  return value !== void 0 && /^[a-f\d]{40,64}$/u.test(value);
+}
+function blob_diff(old, now, root) {
+  if (!is_blob(old) || !is_blob(now)) return void 0;
+  return git_spawn_sync.read(["diff", "--no-ext-diff", "--no-textconv", "-U0", old, now], {
+    cwd: root
+  });
+}
+function is_uncited(lines2, round, file) {
+  return lines2.length === 0 || round.findings.some((finding) => finding.description.length === 0) || lines2.some((line) => round.findings.every((finding) => !cited(finding, file, line)));
+}
+function path_delta(input) {
+  const { file, stamp, now, round, root } = input;
+  const old = stamp.blobs?.[file];
+  const reverse = blob_diff(now[file], old, root);
+  const lines2 = reverse === void 0 ? [] : review_readers_scan.changed_lines(reverse);
+  if (is_uncited(lines2, round, file)) return void 0;
+  const diff = blob_diff(old, now[file], root);
+  return diff === void 0 ? void 0 : `${file}
+${diff}`;
+}
+function block(round, paths, root) {
+  const stamp = review_fix_round.snapshot(round);
+  const now = review_round_one_blobs.capture(paths);
+  if (stamp === void 0 || now === void 0 || paths.length === 0) return void 0;
+  const diffs = paths.map((file) => path_delta({ file, stamp, now, round, root }));
+  if (diffs.includes(void 0)) return void 0;
+  return [
+    "Round 1 rerun \u2014 review only the fix hunks below and the open findings; check the fixes for new defects.",
+    `Previous round: ${round.id}`,
+    ...diffs,
+    "Open findings (locations refer to the previous review):",
+    ...round.findings.filter((finding) => !review_finding_ledger.is_closing(finding.disposition)).map(
+      (finding) => `${finding.category}:${finding.severity}:${finding.file} \u2014 ${finding.description}`
+    )
+  ].join("\n");
+}
+var review_fix_hunks = { block, resumed_block, RESUMED_HEADING };
+
+// scripts/review/review-brief.ts
+var TEST_COMMAND_LINE = "- The unit suite is `pnpm josh test:unit`. Do not reach for `npx vitest`; it is not how this project runs them.";
+var PROSE_STALE_LINE = "- Self-check 2, prose matches the code: `pnpm josh prose:stale` lists each removed name, command, constant or heading docs, prompts or comments still name.";
+function checkout_warning(root) {
+  return `You do not inherit that working directory. Run every command for this review against it \u2014 \`git -C ${root} \u2026\` \u2014 and read no file outside it.`;
+}
+function attest_line(nonce) {
+  return `Attest before you report: run \`pnpm josh review:attest ${nonce}\` from the checkout you actually read. A non-zero exit means it was not the one above \u2014 report \`REVIEW TARGET MISMATCH\` and no findings. Never report "no findings" without that command having passed: a review of the wrong tree finds nothing wrong, and the run cannot tell that apart from approval (joshuafolkken/kit#1522).`;
+}
+var RUBRIC_RELATIVE_PATH = "prompts/review-rubric.md";
+function rubric_line(rubric_path) {
+  return `Rubric: read \`${rubric_path}\` first, with the Read tool rather than \`cat\` \u2014 it is larger than the Bash output cap, so a Bash print comes back truncated (joshuafolkken/kit#2963) \u2014 and apply it: it is the severity tests, the round output format, the nine categories and the stop conditions this review is scored against. You do not carry them otherwise, so a review that skips it is scored on the wrong rules.`;
+}
+function checkout_block(checkout, nonce) {
+  return [
+    `Checkout: ${review_checkout.describe_checkout(checkout)}`,
+    checkout_warning(checkout.root),
+    attest_line(nonce)
+  ].join("\n");
+}
+function whole_change_target(root, base) {
+  const command = `git -C ${root} diff ${base}`;
+  return `Target: the whole change \u2014 \`${command}\` plus the untracked files beside it.`;
+}
+var ROUND_TWO_HEADING = "Round 2 \u2014 a verification pass over the fix delta, not a second full review.";
+var ROUND_TWO_QUESTION = "Ask whether each first-round finding closed and whether the fix itself introduced a defect. Do not re-read the parts of the diff no fix touched.";
+function no_snapshot_line(root, base) {
+  return `No round-1 snapshot was recorded, so the fix delta cannot be named. ${whole_change_target(root, base)}`;
+}
+var EMPTY_DELTA_LINE = "The fix delta is empty \u2014 nothing changed since round 1, so there is nothing for a verification pass to read.";
+var NOT_VERIFIED_LINE = "Not verified: `pnpm josh gate` has not passed on this exact tree. Nothing here claims lint, the type check, the spell check or the unit tests are green.";
+function matching_stamp(stamp, tree) {
+  if (stamp === void 0 || file_map_stamp.changed_since(stamp, tree).length > 0) return void 0;
+  return stamp;
+}
+function verified_line(taken_at) {
+  return `Already verified \u2014 do not re-run these:
+- lint, the type check, the spell check and the unit tests all passed on this exact tree at ${taken_at} (\`pnpm josh gate\`).`;
+}
+function in_flight_line(taken_at) {
+  return `Running now \u2014 do not re-run these:
+- \`pnpm josh gate\` started against this exact tree at ${taken_at} and has not recorded a result. Lint, the type check, the spell check and the unit tests are being run beside this review; the run joins that result before it commits, and it is that result \u2014 never one you produce here \u2014 that gates the merge. Nothing here claims any of them are green.`;
+}
+function live_marker(stamp, tree) {
+  const matched = matching_stamp(stamp, tree);
+  if (!file_map_stamp.is_writer_running(matched)) return void 0;
+  return matched;
+}
+function green_stamp(stamp, tree, base) {
+  const matched = matching_stamp(stamp, tree);
+  if (matched === void 0 || !file_map_stamp.describes_base(matched, base)) return void 0;
+  return matched;
+}
+function gate_line(stamps, tree, base) {
+  const green = green_stamp(stamps.gate, tree, base);
+  if (green !== void 0) return verified_line(green.taken_at);
+  const running = live_marker(stamps.in_flight, tree);
+  if (running !== void 0) return in_flight_line(running.taken_at);
+  return NOT_VERIFIED_LINE;
+}
+var { format_paths: format_paths2, high_fix_lines: high_fix_lines2 } = review_brief_paths;
+var NOTHING_LEFT_LINE = "The fix delta is empty once reconciled against this change \u2014 every path the comparison offered has left it, so there is nothing here for a verification pass to read.";
+function round_two_target(root, scope) {
+  if (scope.target.length > 0) {
+    return `Target: only these files, which are the ones round 1's fixes changed:
+${format_paths2(root, scope.target)}`;
+  }
+  return scope.dropped.length > 0 ? NOTHING_LEFT_LINE : EMPTY_DELTA_LINE;
+}
+function sorted_names(names) {
+  return [...names].toSorted((left, right) => left.localeCompare(right));
+}
+function whole_change_scope(tree) {
+  return {
+    recorded_at: void 0,
+    target: sorted_names(Object.keys(tree)),
+    dropped: [],
+    carried: []
+  };
+}
+function delta_scope(delta, tree, recorded_at) {
+  const target2 = delta.filter((name) => Object.hasOwn(tree, name));
+  return {
+    recorded_at,
+    target: target2,
+    dropped: delta.filter((name) => !Object.hasOwn(tree, name)),
+    carried: sorted_names(Object.keys(tree).filter((name) => !target2.includes(name)))
+  };
+}
+function is_comparable(snapshot2, base) {
+  return snapshot2 !== void 0 && file_map_stamp.describes_base(snapshot2, base);
+}
+function round_two_scope(snapshot2, tree, base) {
+  if (!is_comparable(snapshot2, base)) return whole_change_scope(tree);
+  return delta_scope(file_map_stamp.changed_since(snapshot2, tree), tree, snapshot2.taken_at);
+}
+var BASE_MOVED_PREFIX = "The change base moved since round 1 was recorded";
+function base_moved_line(snapshot2, root, base) {
+  const recorded = snapshot2.base ?? "a commit it did not record";
+  return `${BASE_MOVED_PREFIX} \u2014 round 1 measured this change against ${recorded}, this round measures it against ${base}. The two file maps therefore cover different sets of files, and their difference is not the fix delta. ${whole_change_target(root, base)}`;
+}
+function widened_line(snapshot2, root, base) {
+  if (snapshot2 === void 0) return no_snapshot_line(root, base);
+  return base_moved_line(snapshot2, root, base);
+}
+function dropped_line(root, dropped) {
+  return `Not in this change, so not a target here \u2014 the comparison offered them and \`git diff\` does not list them:
+${format_paths2(root, dropped)}`;
+}
+function carried_line(root, base, count) {
+  return `${String(count)} further file(s) this change touches are byte-identical to round 1 and were read there, so they are deliberately out of scope. Reconcile before you report: \`git -C ${root} diff --name-only ${base}\` plus the untracked files beside it is this change, and every path in it is either a target above or one of those.`;
+}
+function reconciliation(root, base, scope) {
+  return [
+    ...scope.dropped.length > 0 ? [dropped_line(root, scope.dropped)] : [],
+    ...scope.carried.length > 0 ? [carried_line(root, base, scope.carried.length)] : []
+  ];
+}
+function narrow_block(recorded_at, scope, root, base) {
+  return [
+    ROUND_TWO_HEADING,
+    `Round 1 was recorded at ${recorded_at}.`,
+    round_two_target(root, scope),
+    ...reconciliation(root, base, scope),
+    ROUND_TWO_QUESTION
+  ].join("\n");
+}
+function round_two_block(snapshot2, tree, root, base) {
+  const scope = round_two_scope(snapshot2, tree, base);
+  if (scope.recorded_at === void 0) {
+    return `${ROUND_TWO_HEADING}
+${widened_line(snapshot2, root, base)}`;
+  }
+  return narrow_block(scope.recorded_at, scope, root, base);
+}
+function round_one_target(input) {
+  const { root } = input.checkout;
+  const previous = input.fix_round;
+  if (previous !== void 0) {
+    const scope2 = round_two_scope(review_fix_round.snapshot(previous), input.tree, input.base);
+    const paths = [...scope2.target, ...scope2.dropped];
+    return scope2.recorded_at === void 0 ? whole_change_target(root, input.base) : review_fix_hunks.block(previous, paths, root) ?? whole_change_target(root, input.base);
+  }
+  if (input.resumed_from === void 0) return whole_change_target(root, input.base);
+  const scope = round_two_scope(input.resumed_from, input.tree, input.base);
+  return review_fix_hunks.resumed_block({
+    recorded_at: scope.recorded_at,
+    paths: format_paths2(root, scope.target),
+    reconciliation: reconciliation(root, input.base, scope),
+    fallback: whole_change_target(root, input.base)
+  });
+}
+function target_block(input) {
+  if (input.is_full_change) return whole_change_target(input.checkout.root, input.base);
+  if (input.round < review_round.SECOND_ROUND) return round_one_target(input);
+  const { root } = input.checkout;
+  const block2 = round_two_block(input.stamps.round_one, input.tree, root, input.base);
+  return [block2, ...high_fix_lines2(root, input.high_cited)].join("\n");
+}
+function diff_block(input, target2) {
+  if (!target2.includes(whole_change_target(input.checkout.root, input.base)) || input.diff === void 0) {
+    return [];
+  }
+  return ["", review_diff_parts.reading_block(input.diff.parts, input.diff.cap)];
+}
+function readers_block(input, target2) {
+  if (!target2.includes(whole_change_target(input.checkout.root, input.base))) return [];
+  return review_untouched_readers.brief_block(input.readers);
+}
+function interaction_block(targets) {
+  return targets === void 0 ? [] : ["", review_interaction.brief_block(targets)];
+}
+function compose(input) {
+  const profile = input.profile ?? agent_profile_schema.DEFAULT_PROFILES.reviewer;
+  const target2 = target_block(input);
+  return [
+    input.level,
+    "",
+    `Agent profile: ${agent_profile_schema.describe(profile)}`,
+    ...input.is_full_change ? [review_round.FINAL_LINE] : [],
+    "",
+    rubric_line(input.rubric_path),
+    "",
+    checkout_block(input.checkout, input.nonce),
+    "",
+    gate_line(input.stamps, input.tree, input.base),
+    TEST_COMMAND_LINE,
+    PROSE_STALE_LINE,
+    "",
+    target2,
+    ...diff_block(input, target2),
+    ...readers_block(input, target2),
+    ...removed_tests.brief_block(input.removed_tests ?? []),
+    ...interaction_block(input.interaction)
+  ].join("\n");
+}
+var review_brief = {
+  attest_line,
+  BASE_MOVED_PREFIX,
+  carried_line,
+  checkout_warning,
+  compose,
+  dropped_line,
+  EMPTY_DELTA_LINE,
+  gate_line,
+  RESUMED_HEADING: review_fix_hunks.RESUMED_HEADING,
+  matching_stamp,
+  no_snapshot_line,
+  NOTHING_LEFT_LINE,
+  PROSE_STALE_LINE,
+  rubric_line,
+  RUBRIC_RELATIVE_PATH,
+  ROUND_TWO_HEADING,
+  ROUND_TWO_QUESTION,
+  round_two_block,
+  round_two_scope,
+  SECOND_ROUND: review_round.SECOND_ROUND,
+  TEST_COMMAND_LINE,
+  whole_change_target
+};
+
+export {
+  review_finding_text,
+  review_fix_round,
+  review_round,
+  review_brief
+};

package/dist/commands/chunk-5ZXR36N7.js

@@ -0,0 +1,67 @@
+import {
+  REPOSITORY_LABELS
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+
+// scripts/repo/repository-labels.ts
+function labels_endpoint(repo) {
+  return `repos/${repo}/labels`;
+}
+function request(api) {
+  try {
+    return git_gh_exec.exec_gh_api_sync(api);
+  } catch {
+    return void 0;
+  }
+}
+function read_existing(repo) {
+  const path = labels_endpoint(repo);
+  const listing = request({ path, should_paginate: true, jq_filter: ".[].name" });
+  return listing?.split("\n").filter((name) => name.length > 0);
+}
+function missing_labels(existing, wanted) {
+  const names = new Set(existing.map((name) => name.toLowerCase()));
+  return wanted.filter((label) => !names.has(label.name.toLowerCase()));
+}
+function create_label(label, repo) {
+  const body = JSON.stringify(label);
+  const is_created = request({ path: labels_endpoint(repo), method: "POST", body }) !== void 0;
+  if (is_created) console.info(`  \u2714 label ${label.name}`);
+  return is_created;
+}
+function label_names(labels) {
+  return labels.map((label) => label.name);
+}
+function unreadable(wanted, target = "this repository") {
+  const names = label_names(wanted);
+  console.warn(
+    `  \u26A0 could not read the labels of ${target}; make sure these exist: ${names.join(", ")}`
+  );
+  return names;
+}
+function create_missing(missing, repo) {
+  const names = label_names(missing.filter((label) => !create_label(label, repo)));
+  if (names.length > 0) {
+    console.warn(`  \u26A0 could not create these labels; create them by hand: ${names.join(", ")}`);
+  }
+  return names;
+}
+function ensure_labels(repo, extra = []) {
+  const wanted = [...REPOSITORY_LABELS, ...extra];
+  if (repo === void 0) return unreadable(wanted);
+  const existing = read_existing(repo);
+  if (existing === void 0) return unreadable(wanted, repo);
+  return create_missing(missing_labels(existing, wanted), repo);
+}
+function planned_labels(repo) {
+  if (repo === void 0) return label_names(REPOSITORY_LABELS);
+  const existing = read_existing(repo);
+  return existing === void 0 ? void 0 : label_names(missing_labels(existing, REPOSITORY_LABELS));
+}
+var repository_labels = { ensure_labels, planned_labels };
+
+export {
+  repository_labels
+};

package/dist/commands/chunk-623LFKFM.js

@@ -0,0 +1,60 @@
+import {
+  gate_skip
+} from "./chunk-WKXMY7MW.js";
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/gate/hook-gate-reuse.ts
+var GATE_REUSING_TARGETS = ["pre-commit-type-check", "pre-push-unit"];
+var WORKTREE_COLUMN = 1;
+var UNMODIFIED = " ";
+function is_force_requested(force_environment) {
+  return (process.env[force_environment] ?? "") !== "";
+}
+async function read_status_lines() {
+  try {
+    const status = await git_command.status();
+    return status.split("\n").filter((line) => line !== "").filter((line) => !observation_ledger.is_ledger_line(line));
+  } catch {
+    return void 0;
+  }
+}
+function is_worktree_clean(lines) {
+  return lines?.length === 0;
+}
+function is_index_matching_worktree(lines) {
+  return lines?.every((line) => line[WORKTREE_COLUMN] === UNMODIFIED) === true;
+}
+var ARGUMENTS_MISS = "arguments were passed to the hook";
+function force_miss(force_environment) {
+  return `${force_environment} is set`;
+}
+function hook_reuse(input) {
+  if (input.extra_arguments.length > 0) return { miss: ARGUMENTS_MISS };
+  if (is_force_requested(input.force_env)) return { miss: force_miss(input.force_env) };
+  if (!input.is_tree_carried) return { miss: input.carry_miss };
+  return gate_skip.gate_reuse(input.tree.files, input.tree.base, input.source);
+}
+function miss_kind(miss, input) {
+  if (miss === ARGUMENTS_MISS) return "arguments";
+  if (miss === force_miss(input.force_env)) return "forced";
+  if (miss === input.carry_miss) return "tree-not-carried";
+  return gate_skip.miss_kind(miss);
+}
+var hook_gate_reuse = {
+  GATE_REUSING_TARGETS,
+  hook_reuse,
+  is_force_requested,
+  is_index_matching_worktree,
+  is_worktree_clean,
+  miss_kind,
+  read_status_lines
+};
+
+export {
+  hook_gate_reuse
+};