@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/dist/commands/chunk-QEIO2ZNQ.js

@@ -1,324 +0,0 @@
-import {
-  git_pr_merge_checked
-} from "./chunk-HJKZDDDI.js";
-import {
-  main_sync
-} from "./chunk-HRT4KWP4.js";
-import {
-  observation_ledger_prepare
-} from "./chunk-RYZ3RQRH.js";
-import {
-  review_comment_carry
-} from "./chunk-HZBTXKT2.js";
-import {
-  git_gh_command,
-  git_pr_checks
-} from "./chunk-RX5JSPPH.js";
-import {
-  OBSERVATION_LEDGER_DIRECTORY,
-  observation_ledger
-} from "./chunk-4BEIYKI2.js";
-import {
-  IGNORE_FOR_RELEASE_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/observations/observations-flush-landing.ts
-var AUTO_MERGE_WARNING = "Could not enable auto-merge on the flush pull request, so it merges only if this command stays alive to merge it:";
-var MERGE_TIMEOUT_REASON = "auto-merge is enabled, but the pull request did not merge within the checks budget";
-var MERGE_FAILED_REASON = "a required check failed or the branch conflicts, so auto-merge will not land the pull request";
-async function request_auto_merge(branch_name) {
-  try {
-    await git_gh_command.pr_enable_auto_merge(branch_name, await git_command.head_commit());
-    return true;
-  } catch (error) {
-    console.warn(AUTO_MERGE_WARNING, error_text.message_of(error));
-    return false;
-  }
-}
-async function wait_for_landing(branch_name, is_auto_merge) {
-  if (!is_auto_merge) {
-    await git_pr_merge_checked.merge_when_green(branch_name);
-    return;
-  }
-  const progress = await git_pr_checks.wait_for_pr_merged(branch_name);
-  if (progress === "failed") throw new Error(MERGE_FAILED_REASON);
-  if (progress === "waiting") throw new Error(MERGE_TIMEOUT_REASON);
-}
-function describe_pull(pull) {
-  return `${issue_cite.plain_for("github", pull.number)} (\`${pull.head_ref}\`)`;
-}
-async function is_landing(pull) {
-  if (!pull.has_auto_merge) return false;
-  return await git_pr_checks.read_merge_progress(pull.head_ref) !== "failed";
-}
-function landing_flush_message(pulls) {
-  return `deferred \u2014 an earlier flush pull request is still landing with auto-merge on: ${pulls.map((pull) => describe_pull(pull)).join(", ")}. A new flush branch would conflict with it at the ledger's tail, so the appended observations stay in this working tree for the next flush.`;
-}
-function stuck_flush_message(pulls) {
-  return `An earlier \`pnpm josh observations:flush\` left a pull request open that nothing will merge \u2014 unless a flush in another checkout is still waiting on it: ${pulls.map((pull) => describe_pull(pull)).join(", ")}. Its appended observations exist only on that branch \u2014 land it (resolve the ledger conflict if there is one, then merge) before flushing again, or a new flush would conflict with it.`;
-}
-async function refuse_open_flush(branch_prefix) {
-  const pulls = await git_gh_command.pr_list_open_with_head_prefix(branch_prefix);
-  if (pulls.length === 0) return void 0;
-  const verdicts = await Promise.all(pulls.map(async (pull) => await is_landing(pull)));
-  const stuck = pulls.filter((_pull, index) => verdicts[index] !== true);
-  if (stuck.length > 0) throw new Error(stuck_flush_message(stuck));
-  return landing_flush_message(pulls);
-}
-var observations_flush_landing = {
-  landing_flush_message,
-  MERGE_FAILED_REASON,
-  MERGE_TIMEOUT_REASON,
-  refuse_open_flush,
-  request_auto_merge,
-  stuck_flush_message,
-  wait_for_landing
-};
-
-// scripts/observations/observations-flush.ts
-var COMMIT_MESSAGE = "Record observation ledger entries";
-var CLEAN_MESSAGE = `clean \u2014 ${OBSERVATION_LEDGER_DIRECTORY} matches the commit it sits on, so there is nothing to flush`;
-var BRANCH_PREFIX = "observations/";
-var SUCCESS_EXIT_CODE = 0;
-var RETURN_FAILURE_MESSAGE = "Could not return this checkout to the default branch; `pnpm josh ms` printed the reason above.";
-var FAST_FORWARD_FAILURE_MESSAGE = "The flush pull request merged, but the local default branch could not be fast-forwarded to it, so this checkout is still on the flush branch:";
-var DATE_END = 10;
-var TIME_START = 11;
-var TIME_END = 19;
-var COLON = ":";
-var NO_COMMITS = 0;
-var UNKNOWN_COMMIT_COUNT = 1;
-function timestamp_for(now) {
-  const iso = now.toISOString();
-  return `${iso.slice(0, DATE_END)}-${iso.slice(TIME_START, TIME_END).replaceAll(COLON, "")}`;
-}
-function branch_name_for(stamp) {
-  return `${BRANCH_PREFIX}${stamp}`;
-}
-function pull_request_body() {
-  return [
-    `Appended observations from \`${OBSERVATION_LEDGER_DIRECTORY}\` that no run's own commit carried.`,
-    "",
-    "The ledger is append-only, and a second line under one key is what promotes an observation to an issue \u2014 so this pull request adds lines and changes none.",
-    "",
-    "Opened by `pnpm josh observations:flush` (joshuafolkken/kit#1756)."
-  ].join("\n");
-}
-function status_paths(status_output) {
-  return status_output.split("\n").filter((line) => line.trim().length > 0).map((line) => observation_ledger.status_path(line));
-}
-function has_ledger_change(status_output) {
-  return observation_ledger.has_pending_append(status_output);
-}
-function other_changed_paths(status_output) {
-  return status_paths(status_output).filter(
-    (file_path) => !observation_ledger.is_ledger_path(file_path)
-  );
-}
-function stranded_flush_message(current) {
-  return `\`${current}\` is a flush branch an earlier \`pnpm josh observations:flush\` left behind, and its appended observations are committed only there. Land it before flushing again \u2014 \`git push -u origin ${current}\`, then open and merge its pull request; \`pnpm josh ms\` here would leave the only copy of those lines behind.`;
-}
-function empty_flush_message(current) {
-  return `\`${current}\` is a flush branch an earlier \`pnpm josh observations:flush\` left behind with no commit on it, so nothing is stranded: the appended observations are still in this working tree. Run \`pnpm josh ms\` and flush again \u2014 that cuts a fresh branch and loses no line, leaving \`${current}\` as an empty branch to clear whenever it suits you.`;
-}
-function flush_branch_message(current, commit_count) {
-  return commit_count === NO_COMMITS ? empty_flush_message(current) : stranded_flush_message(current);
-}
-function off_default_message(current, default_branch) {
-  return `\`pnpm josh observations:flush\` opens a branch of its own, so it starts from \`${default_branch}\` \u2014 this checkout is on \`${current}\`. Run \`pnpm josh ms\` first.`;
-}
-function behind_default_message(default_branch, reason) {
-  return `\`pnpm josh observations:flush\` cuts its branch from \`${default_branch}\`, which is behind \`origin/${default_branch}\` and could not be fast-forwarded (${reason}) \u2014 a branch cut here would open a pull request that cannot merge. Run \`pnpm josh ms\` first.`;
-}
-function is_flush_branch(current) {
-  return current.startsWith(BRANCH_PREFIX);
-}
-function rejected_commit_message(branch_name, reason) {
-  return `The ledger's commit was rejected, so \`${branch_name}\` was removed and this checkout is back on the default branch: ${reason} \u2014 the appended observations are still in the working tree. Fix what was rejected and run \`pnpm josh observations:flush\` again.`;
-}
-function roll_back_failure_message(branch_name, reason, roll_back_reason) {
-  return `The ledger's commit was rejected and \`${branch_name}\` could not be cleaned up afterwards. The commit was rejected by: ${reason}. The cleanup failed with: ${roll_back_reason}. Nothing was committed to that branch and the appended observations are still in the working tree, so \`pnpm josh ms\` followed by another flush loses no line.`;
-}
-function other_changes_message(paths) {
-  return `The working tree holds changes besides the ledger, so \`pnpm josh observations:flush\` stops rather than committing them: ${paths.join(", ")}`;
-}
-function stranded_branch_message(branch_name, reason) {
-  return `The ledger is committed on \`${branch_name}\` and the flush then failed: ${reason} \u2014 those lines now exist only on that branch, and this checkout is still on it. Finish that branch's pull request before running \`pnpm josh ms\` here.`;
-}
-async function commits_beyond(base, tip) {
-  try {
-    return await git_command.commit_count_beyond(base, tip);
-  } catch {
-    return UNKNOWN_COMMIT_COUNT;
-  }
-}
-async function refuse_off_default(current, default_branch) {
-  if (!is_flush_branch(current)) throw new Error(off_default_message(current, default_branch));
-  throw new Error(flush_branch_message(current, await commits_beyond(default_branch, current)));
-}
-async function commits_behind_default(default_branch) {
-  await git_command.fetch_branch(default_branch);
-  return await git_command.commit_count_beyond("HEAD", `origin/${default_branch}`);
-}
-async function catch_up_default(default_branch) {
-  if (await commits_behind_default(default_branch) === NO_COMMITS) return;
-  try {
-    await git_command.merge_fast_forward(default_branch);
-  } catch (error) {
-    throw new Error(behind_default_message(default_branch, error_text.message_of(error)), {
-      cause: error
-    });
-  }
-}
-async function refuse_unsafe_flush(status_output) {
-  const current = await git_command.branch();
-  const default_branch = await git_command.get_default_branch();
-  if (current !== default_branch) await refuse_off_default(current, default_branch);
-  const others = other_changed_paths(status_output);
-  if (others.length > 0) throw new Error(other_changes_message(others));
-  return default_branch;
-}
-async function return_to_default_branch(default_branch) {
-  try {
-    await git_command.fast_forward_local(default_branch);
-  } catch (error) {
-    throw new Error(`${FAST_FORWARD_FAILURE_MESSAGE} ${error_text.message_of(error)}`, {
-      cause: error
-    });
-  }
-  const exit_code = await main_sync.run([]);
-  if (exit_code !== SUCCESS_EXIT_CODE) throw new Error(RETURN_FAILURE_MESSAGE);
-}
-async function push_and_open(branch_name) {
-  try {
-    await git_command.push();
-    return await git_gh_command.pr_create(
-      COMMIT_MESSAGE,
-      pull_request_body(),
-      IGNORE_FOR_RELEASE_LABEL
-    );
-  } catch (error) {
-    throw new Error(stranded_branch_message(branch_name, error_text.message_of(error)), {
-      cause: error
-    });
-  }
-}
-async function roll_back(branch_name, default_branch) {
-  try {
-    await git_command.checkout(default_branch);
-    await git_command.delete_branch(branch_name);
-    return void 0;
-  } catch (error) {
-    return error_text.message_of(error);
-  }
-}
-function rejection_message(branch_name, reason, roll_back_reason) {
-  if (roll_back_reason === void 0) return rejected_commit_message(branch_name, reason);
-  return roll_back_failure_message(branch_name, reason, roll_back_reason);
-}
-async function stage_ledger() {
-  const ledger_paths = observation_ledger.ledger_paths(await git_command.status());
-  for (const file_path of ledger_paths) {
-    await git_command.add_path(file_path);
-  }
-}
-async function commit_ledger(branch_name, default_branch) {
-  try {
-    await stage_ledger();
-    await git_command.commit(COMMIT_MESSAGE);
-  } catch (error) {
-    const roll_back_reason = await roll_back(branch_name, default_branch);
-    throw new Error(
-      rejection_message(branch_name, error_text.message_of(error), roll_back_reason),
-      {
-        cause: error
-      }
-    );
-  }
-}
-async function open_pull_request(branch_name, default_branch) {
-  await git_command.checkout_b(branch_name);
-  await commit_ledger(branch_name, default_branch);
-  return await push_and_open(branch_name);
-}
-async function land(branch_name, default_branch, is_auto_merge) {
-  try {
-    await observations_flush_landing.wait_for_landing(branch_name, is_auto_merge);
-  } catch (error) {
-    throw new Error(stranded_branch_message(branch_name, error_text.message_of(error)), {
-      cause: error
-    });
-  }
-  await return_to_default_branch(default_branch);
-}
-async function open_and_land(branch_name, default_branch) {
-  console.info(await open_pull_request(branch_name, default_branch));
-  const is_auto_merge = await observations_flush_landing.request_auto_merge(branch_name);
-  await land(branch_name, default_branch, is_auto_merge);
-}
-function merged_message(branch_name) {
-  return `merged \`${branch_name}\` \u2014 the appended observations are on the default branch`;
-}
-function broken_lines_message(broken) {
-  const rows = broken.map((entry) => `  ${entry.line}
-    \u21B3 ${entry.reason}`).join("\n");
-  return `\`${OBSERVATION_LEDGER_DIRECTORY}\` has ${String(broken.length)} line(s) that break the ledger grammar, so the ledger commit stops rather than carrying them:
-${rows}`;
-}
-async function prepare_ledger() {
-  const broken = await observation_ledger_prepare.prepare(process.cwd());
-  if (broken.length > 0) throw new Error(broken_lines_message(broken));
-}
-async function ready_default_branch(status_output) {
-  const default_branch = await refuse_unsafe_flush(status_output);
-  review_comment_carry.discard_uncommitted(status_output, process.cwd());
-  await catch_up_default(default_branch);
-  return default_branch;
-}
-async function carried_status() {
-  await review_comment_carry.carry_reported(process.cwd());
-  return await git_command.status();
-}
-async function flush(now) {
-  const default_branch = await ready_default_branch(await git_command.status());
-  const deferred = await observations_flush_landing.refuse_open_flush(BRANCH_PREFIX);
-  if (deferred !== void 0) return deferred;
-  const status_output = await carried_status();
-  if (!has_ledger_change(status_output)) return CLEAN_MESSAGE;
-  await prepare_ledger();
-  const branch_name = branch_name_for(timestamp_for(now));
-  await open_and_land(branch_name, default_branch);
-  return merged_message(branch_name);
-}
-var observations_flush = {
-  behind_default_message,
-  branch_name_for,
-  broken_lines_message,
-  CLEAN_MESSAGE,
-  COMMIT_MESSAGE,
-  flush,
-  flush_branch_message,
-  has_ledger_change,
-  merged_message,
-  off_default_message,
-  other_changed_paths,
-  other_changes_message,
-  pull_request_body,
-  rejected_commit_message,
-  roll_back_failure_message,
-  stranded_branch_message,
-  timestamp_for
-};
-
-export {
-  observations_flush
-};

package/dist/commands/chunk-QWX7EBC6.js

@@ -1,112 +0,0 @@
-import {
-  JOSH_TMP_DIRECTORY
-} from "./chunk-LAYSCY4L.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/cut/run-cut-handoff.ts
-import { readFileSync } from "node:fs";
-import { z } from "zod";
-var handoff_schema = z.object({
-  instruction: z.string(),
-  completed: z.array(z.string()),
-  remaining: z.array(z.string()),
-  untouched: z.array(z.string()),
-  findings: z.array(z.string()).optional()
-});
-var COMPLETED_LABEL = "Completed";
-var REMAINING_LABEL = "Remaining";
-var UNTOUCHED_LABEL = "Deliberately untouched";
-var INSTRUCTION_LABEL = "Instruction (verbatim)";
-var FINDINGS_LABEL = "Round-1 findings, attested but not recorded \u2014 do not rerun round 1: fix them, then record them with `pnpm josh review:record --issue <N>`";
-var EMPTY_LIST_NOTE = "(none)";
-var PLACEHOLDER = "\u2026";
-var FINDINGS_PLACEHOLDER = "unrecorded";
-var EXAMPLE_LIST = `["${PLACEHOLDER}"]`;
-var EXAMPLE_VALUES = {
-  instruction: `"${PLACEHOLDER}"`,
-  completed: EXAMPLE_LIST,
-  remaining: EXAMPLE_LIST,
-  untouched: EXAMPLE_LIST,
-  findings: `["${FINDINGS_PLACEHOLDER}"]`
-};
-var HANDOFF_FORMAT = `{${handoff_schema.keyof().options.map((key) => `"${key}":${EXAMPLE_VALUES[key]}`).join(",")}}`;
-function parse_handoff(raw) {
-  return json_value.parse_with(raw, handoff_schema);
-}
-function read_handoff_file(handoff_path) {
-  try {
-    return parse_handoff(readFileSync(handoff_path, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function is_complete_handoff(handoff) {
-  return handoff !== void 0 && handoff.instruction.trim() !== "";
-}
-function is_within_bound(handoff, max_bytes) {
-  return Buffer.byteLength(JSON.stringify(handoff), "utf8") <= max_bytes;
-}
-function load_handoff(handoff_path, max_bytes) {
-  if (handoff_path === void 0) return { kind: "ok", handoff: void 0 };
-  const handoff = read_handoff_file(handoff_path);
-  if (handoff === void 0) {
-    return {
-      kind: "bad",
-      note: `--handoff ${handoff_path} is not a readable handoff file \u2014 write ${HANDOFF_FORMAT}`
-    };
-  }
-  if (!is_within_bound(handoff, max_bytes)) {
-    return { kind: "bad", note: `--handoff ${handoff_path} is too large to carry across the cut` };
-  }
-  return { kind: "ok", handoff };
-}
-function describe_list(label, items) {
-  if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
-  const bullets = items.map((item) => `  - ${item}`).join("\n");
-  return `${label}:
-${bullets}`;
-}
-function carried_findings(handoff) {
-  const findings = handoff?.findings ?? [];
-  return findings.filter(
-    (finding) => ![PLACEHOLDER, FINDINGS_PLACEHOLDER, ""].includes(finding.trim())
-  );
-}
-function describe_findings(handoff) {
-  const findings = carried_findings(handoff);
-  if (findings.length === 0) return [];
-  return [describe_list(FINDINGS_LABEL, findings)];
-}
-function describe_handoff(handoff) {
-  return [
-    `${INSTRUCTION_LABEL}:
-${handoff.instruction}`,
-    describe_list(COMPLETED_LABEL, handoff.completed),
-    describe_list(REMAINING_LABEL, handoff.remaining),
-    describe_list(UNTOUCHED_LABEL, handoff.untouched),
-    ...describe_findings(handoff)
-  ].join("\n\n");
-}
-var HANDOFF_PATH = `${JOSH_TMP_DIRECTORY}/handoff-<N>.json`;
-var ISSUE_PLACEHOLDER = "<N>";
-function handoff_path_of(issue) {
-  return HANDOFF_PATH.replace(ISSUE_PLACEHOLDER, () => issue);
-}
-var run_cut_handoff = {
-  HANDOFF_FORMAT,
-  HANDOFF_PATH,
-  handoff_path_of,
-  carried_findings,
-  describe_handoff,
-  handoff_schema,
-  is_complete_handoff,
-  load_handoff,
-  parse_handoff,
-  read_handoff_file
-};
-
-export {
-  run_cut_handoff
-};

package/dist/commands/chunk-RQRLW4XK.js

@@ -1,20 +0,0 @@
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-stage-budget.ts
-var BUDGET_MINUTES = {
-  plan: 3,
-  implement: 9,
-  ship: 8,
-  followup: 5
-};
-function over_minutes(stage, elapsed_ms) {
-  const over_ms = elapsed_ms - BUDGET_MINUTES[stage] * MS_PER_MINUTE;
-  return over_ms > 0 ? Math.ceil(over_ms / MS_PER_MINUTE) : void 0;
-}
-var lane_stage_budget = { BUDGET_MINUTES, over_minutes };
-
-export {
-  lane_stage_budget
-};

package/dist/commands/chunk-UCQJDYE3.js

@@ -1,21 +0,0 @@
-// scripts/time-runtime/transcript-tail.ts
-import { closeSync, fstatSync, openSync, readSync } from "node:fs";
-var TAIL_BYTES = 262144;
-var FILE_START = 0;
-function read_tail(file_path, max_bytes = TAIL_BYTES) {
-  const descriptor = openSync(file_path, "r");
-  try {
-    const { size } = fstatSync(descriptor);
-    const length = Math.min(size, max_bytes);
-    const buffer = Buffer.alloc(length);
-    const read = readSync(descriptor, buffer, FILE_START, length, size - length);
-    return buffer.subarray(FILE_START, read).toString("utf8");
-  } finally {
-    closeSync(descriptor);
-  }
-}
-var transcript_tail = { TAIL_BYTES, read_tail };
-
-export {
-  transcript_tail
-};

package/dist/commands/chunk-W4YH2DF3.js

@@ -1,58 +0,0 @@
-import {
-  time_josh_names,
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-
-// scripts/rules/shell-segments.ts
-var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
-var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
-var COMMAND_SEPARATOR = /&&|\|\||;|\n|(?<!>)\|&?|(?<![<>])&(?!>)/u;
-function segments_of(command) {
-  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
-}
-function commands_of(command) {
-  return command.split(COMMAND_SEPARATOR).map((segment) => segment.trim());
-}
-var COMMAND_SEPARATORS = new RegExp(COMMAND_SEPARATOR.source, "gu");
-function quote_aware_commands_of(command) {
-  const plain = time_shell.blanked(command);
-  if (plain === void 0) return commands_of(command);
-  const cuts = [...plain.matchAll(COMMAND_SEPARATORS)].map((match) => ({
-    begin: match.index,
-    end: match.index + match[0].length
-  }));
-  const starts = [0, ...cuts.map((cut) => cut.end)];
-  const stops = cuts.map((cut) => cut.begin);
-  return starts.map((start, index) => command.slice(start, stops[index] ?? command.length).trim());
-}
-var LINE_CONTINUATION = /\\\n/gu;
-function joined_continuations(command) {
-  return command.replaceAll(LINE_CONTINUATION, " ");
-}
-function parts_of(command) {
-  return command.split(SEGMENT_PARTS);
-}
-function first_of(command) {
-  const plain = time_shell.blanked(command);
-  if (plain === void 0) return void 0;
-  const cut = plain.search(SEGMENT_SEPARATOR);
-  return (cut === -1 ? command : command.slice(0, cut)).trim();
-}
-function is_josh_command(segment, names) {
-  const named = time_josh_names.josh_command_of(segment);
-  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
-  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
-}
-var shell_segments = {
-  commands_of,
-  first_of,
-  is_josh_command,
-  joined_continuations,
-  parts_of,
-  quote_aware_commands_of,
-  segments_of
-};
-
-export {
-  shell_segments
-};

package/dist/commands/{chunk-LRA3PXHS.js → chunk-ENKFCOVY.js}

@@ -4,14 +4,14 @@ import {
 import {
   git_gh_transport
 } from "./chunk-TVZXG4Y4.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
 import {
   MERGED_STATE,
   git_gh_helpers,
   to_gh_state
 } from "./chunk-4PUKDAXL.js";
+import {
+  gh_author_association
+} from "./chunk-XXNEY4B3.js";
 import {
   git_gh_etag_read,
   git_gh_issue_memo

package/dist/commands/{chunk-RUWV4INF.js → chunk-HQGNXR6I.js}

@@ -1,9 +1,9 @@
-import {
-  josh_verdict
-} from "./chunk-JTU5A4JI.js";
 import {
   unit_worker_share
 } from "./chunk-MDLOETXL.js";
+import {
+  josh_verdict
+} from "./chunk-JTU5A4JI.js";
 import {
   gate_labels
 } from "./chunk-WQ6FS544.js";