@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-DVIOBFU7.js

@@ -0,0 +1,210 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+
+// scripts/run/park/run-park-body.ts
+var OPTIONS_HEADING = "### \u9078\u629E\u80A2";
+var PICK_HEADING = "### \u63A8\u5968";
+var NO_PICK_WORD = "\u63A8\u5968\u306A\u3057";
+var TIER_LINE = "   - \u5C64: A|B|C";
+var ANY_HEADING = /^#{1,6} /u;
+var ITEM = /^(\d+)\. +\S/u;
+var TIER = /^- 層: ?([ABC])$/u;
+var PERMISSION = /^- 必要な権限: ?(\S.*)$/u;
+var APPROVAL_PATHS = /^- 規模承認のパス: ?(\S.*)$/u;
+var APPROVAL_LINES = /^- 規模承認の行数: ?([1-9]\d*) *\/ *([1-9]\d*)$/u;
+var APPROVAL_FILES = /^- 規模承認のファイル数: ?([1-9]\d*) *\/ *([1-9]\d*)$/u;
+var PATH_SEPARATOR = /[\s,、]+/u;
+var APPROVAL_PARTS = [
+  ["paths", "- \u898F\u6A21\u627F\u8A8D\u306E\u30D1\u30B9: <path> \u2026"],
+  ["lines", "- \u898F\u6A21\u627F\u8A8D\u306E\u884C\u6570: <declared> / <max>"],
+  ["files", "- \u898F\u6A21\u627F\u8A8D\u306E\u30D5\u30A1\u30A4\u30EB\u6570: <declared> / <max>"]
+];
+var PICK = /^(\d+)[\s:：.、]+\S/u;
+var NO_PICK = /^推奨なし[\s:：—-]+\S/u;
+var AUTO_TIER = "A";
+var PERSON_TIER = "C";
+var AUTO_PERMISSION = "\u306A\u3057";
+var PARENT_PERMISSION = "\u89AA";
+var PARENT_ACTION_NOTE = " \xB7 \u89AA\u306E\u64CD\u4F5C";
+var FORMAT = [
+  "Park body schema:",
+  OPTIONS_HEADING,
+  "1. <option>",
+  TIER_LINE,
+  "   - \u5FC5\u8981\u306A\u6A29\u9650: \u306A\u3057 | \u89AA | owner \u30B3\u30E1\u30F3\u30C8 | epic \u7DE8\u96C6 | \u4FE1\u983C\u8A2D\u5B9A | \u4EBA",
+  "2. <option>",
+  TIER_LINE,
+  "   - \u5FC5\u8981\u306A\u6A29\u9650: \u2026",
+  "   (a size-approval option adds all three:)",
+  ...APPROVAL_PARTS.map(([, line]) => `   ${line}`),
+  PICK_HEADING,
+  `<option number> <reason>   (or: ${NO_PICK_WORD} <reason>)`
+].join("\n");
+function section_of(lines, heading) {
+  const start = lines.findIndex((line) => line.trim() === heading);
+  if (start === -1) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => ANY_HEADING.test(line));
+  return end === -1 ? rest : rest.slice(0, end);
+}
+function tier_of(option, line) {
+  return option.tier ?? TIER.exec(line)?.[1];
+}
+function permission_of(option, line) {
+  return option.permission ?? PERMISSION.exec(line)?.[1]?.trim();
+}
+function bound_of(pattern, line) {
+  const [, declared, max] = pattern.exec(line) ?? [];
+  return max === void 0 ? void 0 : { declared: Number(declared), max: Number(max) };
+}
+function paths_of(line) {
+  const text = APPROVAL_PATHS.exec(line)?.[1];
+  const paths = text?.split(PATH_SEPARATOR).map((path) => path.replaceAll("`", "")).filter(Boolean);
+  return paths?.length === 0 ? void 0 : paths;
+}
+function approval_of(approval, line) {
+  const paths = paths_of(line);
+  if (paths !== void 0) return { ...approval, paths };
+  const lines = bound_of(APPROVAL_LINES, line);
+  if (lines !== void 0) return { ...approval, lines };
+  const files = bound_of(APPROVAL_FILES, line);
+  return files === void 0 ? approval : { ...approval, files };
+}
+function with_detail(option, raw_line) {
+  const line = raw_line.trim();
+  const approval = approval_of(option.approval, line);
+  return {
+    ...option,
+    tier: tier_of(option, line),
+    permission: permission_of(option, line),
+    approval
+  };
+}
+function next_options(options, line) {
+  const number = ITEM.exec(line)?.[1];
+  if (number !== void 0) return [...options, { number: Number(number) }];
+  const last = options.at(-1);
+  return last === void 0 ? options : [...options.slice(0, -1), with_detail(last, line)];
+}
+function options_of(lines) {
+  let options = [];
+  for (const line of lines) options = next_options(options, line);
+  return options;
+}
+function first_line(lines) {
+  return lines.find((candidate) => candidate.trim() !== "")?.trim() ?? "";
+}
+function pick_of(lines) {
+  const line = first_line(lines);
+  if (NO_PICK.test(line)) return {};
+  const number = PICK.exec(line)?.[1];
+  return number === void 0 ? void 0 : { number: Number(number) };
+}
+function parse(body) {
+  const lines = markdown_section.fence_free_lines(body);
+  return {
+    options: options_of(section_of(lines, OPTIONS_HEADING)),
+    pick: pick_of(section_of(lines, PICK_HEADING))
+  };
+}
+function approval_problem(approval, name) {
+  if (approval === void 0) return void 0;
+  const missing = APPROVAL_PARTS.find(([key]) => approval[key] === void 0);
+  return missing === void 0 ? void 0 : `${name} has no "${missing[1]}" line`;
+}
+function option_problem(option) {
+  const name = `option ${String(option.number)}`;
+  if (option.tier === void 0) return `${name} has no "- \u5C64: A|B|C" line`;
+  if (option.permission === void 0) return `${name} has no "- \u5FC5\u8981\u306A\u6A29\u9650: \u2026" line`;
+  return approval_problem(option.approval, name);
+}
+function is_listed(park, number) {
+  return number === void 0 || park.options.some((option) => option.number === number);
+}
+function pick_problem(park) {
+  if (park.pick === void 0) {
+    return `${PICK_HEADING} needs one line: "<option number> <reason>" or "${NO_PICK_WORD} <reason>"`;
+  }
+  if (is_listed(park, park.pick.number)) return void 0;
+  return `${PICK_HEADING} names option ${String(park.pick.number)}, which ${OPTIONS_HEADING} does not list`;
+}
+function problem_of(body) {
+  const park = parse(body);
+  if (park.options.length === 0) return `${OPTIONS_HEADING} lists no numbered option`;
+  return park.options.map((option) => option_problem(option)).find(Boolean) ?? pick_problem(park);
+}
+function picked_option(body) {
+  const park = parse(body);
+  const number = park.pick?.number;
+  return park.options.find((candidate) => candidate.number === number);
+}
+function is_parent_action(option) {
+  return option?.permission?.startsWith(PARENT_PERMISSION) === true;
+}
+function summary_of(body) {
+  if (problem_of(body) !== void 0) return void 0;
+  const option = picked_option(body);
+  if (option === void 0) return NO_PICK_WORD;
+  const note = is_parent_action(option) ? PARENT_ACTION_NOTE : "";
+  return `\u63A8\u5968: ${String(option.number)}\uFF08\u5C64 ${option.tier ?? ""}${note}\uFF09`;
+}
+function parent_action(body, number) {
+  return is_parent_action(parse(body).options.find((candidate) => candidate.number === number));
+}
+function is_parents(option) {
+  return option.tier === AUTO_TIER && option.permission === AUTO_PERMISSION;
+}
+function auto_pick(body) {
+  if (problem_of(body) !== void 0) return void 0;
+  const option = picked_option(body);
+  return option !== void 0 && is_parents(option) ? option.number : void 0;
+}
+function adopt_problem(body, number) {
+  const park = parse(body);
+  if (park.pick?.number === void 0) return `the park says ${NO_PICK_WORD}, so a person decides`;
+  const option = park.options.find((candidate) => candidate.number === number);
+  if (option === void 0) return `${OPTIONS_HEADING} lists no option ${String(number)}`;
+  return option.tier === PERSON_TIER ? `option ${String(number)} is tier C, a person's to take` : void 0;
+}
+function adoptable_pick(body) {
+  const number = picked_option(body)?.number;
+  return number !== void 0 && adopt_problem(body, number) === void 0 ? number : void 0;
+}
+function is_narrowest(option) {
+  const { tier, permission, approval } = option;
+  return tier !== PERSON_TIER && permission === AUTO_PERMISSION && approval === void 0;
+}
+function unpicked_options(body) {
+  const park = parse(body);
+  return problem_of(body) === void 0 && park.pick?.number === void 0 ? park.options : [];
+}
+function default_pick(body) {
+  const options = unpicked_options(body);
+  const number = options.find((option) => is_narrowest(option))?.number;
+  const over = options.map((option) => option.number).filter((other) => other !== number);
+  return number === void 0 ? void 0 : { number, over };
+}
+function is_complete(approval) {
+  return APPROVAL_PARTS.every(([key]) => approval?.[key] !== void 0);
+}
+function approval_range(body, number) {
+  const option = parse(body).options.find((candidate) => candidate.number === number);
+  return is_complete(option?.approval) ? option.approval : void 0;
+}
+var run_park_body = {
+  FORMAT,
+  HEADINGS: [OPTIONS_HEADING, PICK_HEADING],
+  adopt_problem,
+  adoptable_pick,
+  approval_range,
+  auto_pick,
+  default_pick,
+  parent_action,
+  problem_of,
+  summary_of
+};
+
+export {
+  run_park_body
+};

package/dist/commands/chunk-E5CGA7FC.js

@@ -0,0 +1,114 @@
+import {
+  lane_breakdown_implement
+} from "./chunk-UWLANGIR.js";
+import {
+  lane_breakdown,
+  lane_breakdown_pause
+} from "./chunk-2MDLCJZ4.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+
+// scripts/lane/lane-breakdown-laps.ts
+var { KIND } = lane_ledger;
+var CORE_WAIT_STEP = "core-budget wait";
+var REUSED_NOTE = "(reused)";
+function rerun_note(entry) {
+  if (entry.rerun === void 0) return [];
+  return [entry.runs === void 0 ? entry.rerun : `run ${String(entry.runs)}: ${entry.rerun}`];
+}
+function lap_name(entry) {
+  if (entry.reused_tree !== void 0) return `${entry.step} ${REUSED_NOTE}`;
+  const run = rerun_note(entry);
+  const whole = entry.fallback === void 0 ? [] : [`whole branch: ${entry.fallback}`];
+  const notes = [...run, ...whole];
+  return notes.length === 0 ? entry.step : `${entry.step} (${notes.join("; ")})`;
+}
+function lap_of(entry, issue) {
+  if (entry.kind !== KIND.SHIP_LAP || entry.issue !== issue) return [];
+  return [
+    {
+      at_ms: Date.parse(entry.at),
+      part: { name: lap_name(entry), ms: entry.elapsed_ms },
+      stage: entry.stage === "run:entry" ? lane_breakdown.PLAN_STAGE : void 0
+    }
+  ];
+}
+function wait_of(entry, issue) {
+  if (entry.kind !== KIND.CORE_WAIT || entry.issue !== issue) return [];
+  return [{ at_ms: Date.parse(entry.at), part: { name: CORE_WAIT_STEP, ms: entry.waited_ms } }];
+}
+function checks_of(entry, issue) {
+  if (entry.kind !== KIND.GATE || entry.issue !== issue) return [];
+  const at_ms = Date.parse(entry.at);
+  return (entry.checks ?? []).filter((check) => check.is_reused !== true).map((check) => ({ at_ms, part: { name: check.label, ms: check.elapsed_ms } }));
+}
+function stage_at(segments, at_ms) {
+  const segment = segments.find((span) => at_ms > span.from_ms && at_ms <= span.to_ms);
+  return segment?.stage === lane_breakdown.BETWEEN_STAGE ? void 0 : segment?.stage;
+}
+function stage_for(place, segments) {
+  if (place.stage === void 0) return stage_at(segments, place.at_ms);
+  return segments.some((segment) => segment.stage === place.stage) ? place.stage : void 0;
+}
+function grouped(placed, segments, groups = /* @__PURE__ */ new Map()) {
+  for (const place of placed) {
+    const stage = stage_for(place, segments);
+    if (stage !== void 0) groups.set(stage, [...groups.get(stage) ?? [], place.part]);
+  }
+  return groups;
+}
+function counted(parts) {
+  const reuses = /* @__PURE__ */ new Map();
+  for (const { name } of parts) {
+    if (name.endsWith(REUSED_NOTE)) reuses.set(name, (reuses.get(name) ?? 0) + 1);
+  }
+  return parts.map((part) => {
+    const count = reuses.get(part.name);
+    return count === void 0 ? part : { ...part, name: `${part.name.slice(0, -REUSED_NOTE.length)}(reused \xD7${String(count)})` };
+  });
+}
+function paused_of(segment, breakdown) {
+  const mark = lane_breakdown_pause.in_segment(breakdown.pauses ?? [], segment);
+  if (mark === void 0) return [];
+  const waited_ms = lane_breakdown.covered_ms(segment, breakdown.waits);
+  return [{ name: mark.name, ms: segment.to_ms - segment.from_ms - waited_ms }];
+}
+function between_of(calls, breakdown) {
+  const between = breakdown.ship.filter((segment) => segment.stage === lane_breakdown.BETWEEN_STAGE);
+  const paused = between.map((segment) => paused_of(segment, breakdown));
+  const unpaused = between.filter((_segment, index) => paused[index]?.length === 0);
+  return lane_breakdown.ranked([
+    ...paused.flat(),
+    ...lane_breakdown_implement.between_kinds(calls, unpaused, breakdown.waits)
+  ]);
+}
+function plan_segments(breakdown) {
+  return (breakdown.plan ?? []).map((span) => ({ ...span, stage: lane_breakdown.PLAN_STAGE }));
+}
+function of(entries, issue, breakdown, calls) {
+  const lapped = entries.flatMap((entry) => lap_of(entry, issue));
+  const placed = entries.flatMap((entry) => [...wait_of(entry, issue), ...checks_of(entry, issue)]);
+  const planned = grouped(lapped, plan_segments(breakdown));
+  const laps = new Map(
+    [...grouped([...lapped, ...placed], breakdown.ship, planned)].map(([stage, parts]) => [
+      stage,
+      lane_breakdown.ranked(counted(parts))
+    ])
+  );
+  const between = between_of(calls, breakdown);
+  if (between.length > 0) laps.set(lane_breakdown.BETWEEN_STAGE, between);
+  return laps;
+}
+function ship_parts(entries, issue, breakdown) {
+  const placed = entries.flatMap((entry) => [...lap_of(entry, issue), ...wait_of(entry, issue)]);
+  return [...grouped(placed, breakdown.ship).values()].flat();
+}
+function is_in_ship(breakdown, at) {
+  return stage_at(breakdown.ship, Date.parse(at)) !== void 0;
+}
+var lane_breakdown_laps = { CORE_WAIT_STEP, is_in_ship, of, ship_parts };
+
+export {
+  lane_breakdown_laps
+};

package/dist/commands/chunk-EG44IWNI.js

@@ -0,0 +1,88 @@
+import {
+  live_evidence
+} from "./chunk-MOLXF5KO.js";
+import {
+  acceptance_map
+} from "./chunk-VP3P7FLJ.js";
+import {
+  removed_tests
+} from "./chunk-ISNZX75X.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/run/ship/run-ship-body-draft.ts
+import { access, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+var BODY_FILE_OPTION = "body-file";
+var DRAFT_PREFIX = "josh-ship-body-";
+var DRAFT_SUFFIX = ".md";
+var EXISTS_CODE = "EEXIST";
+var NO_GIT_DIRECTORY = "no git directory to hold the ship body draft";
+async function path_of(issue_number) {
+  const [git_directory] = await git_command.git_directories();
+  if (git_directory === void 0) throw new Error(NO_GIT_DIRECTORY);
+  return path.join(git_directory, `${DRAFT_PREFIX}${issue_number}${DRAFT_SUFFIX}`);
+}
+function is_exists_error(error) {
+  return error instanceof Error && "code" in error && error.code === EXISTS_CODE;
+}
+var FORMAT_HINTS = [
+  acceptance_map.ROW_FORMAT,
+  live_evidence.EVIDENCE_FORMAT,
+  `when the change removes or renames a test, ${removed_tests.ROW_FORMAT}`
+];
+function hint_line(format) {
+  return `<!-- ${format} -->`;
+}
+function draft_text(acceptance_rows) {
+  const hints = FORMAT_HINTS.map((format) => hint_line(format)).join("\n");
+  return `${acceptance_rows}
+
+${hints}
+
+${live_evidence.EVIDENCE_HEADING}
+`;
+}
+async function prepare(issue_number, acceptance_rows) {
+  const target = await path_of(issue_number);
+  try {
+    await writeFile(target, draft_text(acceptance_rows), { flag: "wx" });
+  } catch (error) {
+    if (!is_exists_error(error)) throw error;
+  }
+  return target;
+}
+async function existing(issue_number) {
+  const target = await path_of(issue_number);
+  try {
+    await access(target);
+    return target;
+  } catch {
+    return void 0;
+  }
+}
+async function remove(issue_number) {
+  await rm(await path_of(issue_number), { force: true });
+}
+function body_arguments(body_path) {
+  return body_path === void 0 ? [] : [`--${BODY_FILE_OPTION}`, body_path];
+}
+async function with_draft(args) {
+  if (args.body_path !== void 0) return args;
+  const draft = await existing(args.number);
+  return draft === void 0 ? args : { ...args, body: body_arguments(draft), body_path: draft };
+}
+var run_ship_body_draft = {
+  BODY_FILE_OPTION,
+  body_arguments,
+  existing,
+  path_of,
+  prepare,
+  remove,
+  with_draft
+};
+
+export {
+  run_ship_body_draft
+};

package/dist/commands/chunk-EHVFQQO6.js

@@ -0,0 +1,45 @@
+import {
+  run_cut
+} from "./chunk-OTCWA4QE.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/cut/run-cut-decline.ts
+import { z } from "zod";
+var DECLINE_PREFIX = "josh-run-cut-decline-";
+var decline_schema = z.object({ issue: z.string(), hold_taken_at: z.string().optional() });
+function decline_path(git_directory) {
+  return stamp_file.stamp_path(DECLINE_PREFIX, git_directory);
+}
+function record(git_directory, decline) {
+  stamp_file.replace_stamp(decline_path(git_directory), decline);
+}
+function read(git_directory) {
+  const raw = stamp_file.read_stamp_text(decline_path(git_directory));
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, decline_schema);
+}
+function matches(recorded, current) {
+  return recorded?.issue === current.issue && recorded.hold_taken_at === current.hold_taken_at;
+}
+function is_declined_sync(issue, directory = run_cut.worktree_git_directory_sync()) {
+  if (directory === void 0) return false;
+  const hold_taken_at = run_cut.hold_of(directory)?.taken_at;
+  return matches(read(directory), { issue, hold_taken_at });
+}
+async function declined(request, state, code) {
+  if (request.phase !== run_cut.IMPLEMENTATION_PHASE) return code;
+  const directory = await run_cut.worktree_directory();
+  if (directory !== void 0) {
+    record(directory, { issue: request.issue, hold_taken_at: state.hold_taken_at });
+  }
+  return code;
+}
+var run_cut_decline = { decline_path, declined, is_declined_sync, read, record };
+
+export {
+  run_cut_decline
+};