@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-IQMMYORJ.js

@@ -0,0 +1,554 @@
+import {
+  run_hold_block
+} from "./chunk-BGKUZJT7.js";
+import {
+  run_cli_fault
+} from "./chunk-HRLGFRAV.js";
+import {
+  run_halfrun_resume,
+  run_hold_session
+} from "./chunk-A73RWSHJ.js";
+import {
+  run_label,
+  run_maintenance
+} from "./chunk-6NXTP5JT.js";
+import {
+  telegram_test
+} from "./chunk-HLQVLQEB.js";
+import {
+  test_e2e_stamp
+} from "./chunk-U7JJGYYY.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  git_gh_repo
+} from "./chunk-QRY55H5U.js";
+import {
+  run_preflight
+} from "./chunk-ZNFVJETO.js";
+import {
+  git_gh_pr_read
+} from "./chunk-3PGB2RKZ.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  run_ship_lap
+} from "./chunk-3W2TJZMD.js";
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/lib/stdout-on-stderr.ts
+function set_stdout_write(stream_write) {
+  process.stdout.write = stream_write;
+}
+async function run(work) {
+  const saved = { write: process.stdout.write.bind(process.stdout) };
+  set_stdout_write(process.stderr.write.bind(process.stderr));
+  try {
+    return await work();
+  } finally {
+    set_stdout_write(saved.write);
+  }
+}
+var stdout_on_stderr = { run };
+
+// scripts/run/run-prrun-resume.ts
+var PRRUN_MERGED = "prrun-merged";
+var PRRUN_MERGE = "prrun-merge";
+var PRRUN_GATE = "prrun-gate";
+function is_untouched(facts) {
+  return facts.head === facts.stop_head && facts.pr_head === facts.stop_head && !facts.is_dirty;
+}
+function decide(facts) {
+  if (facts.is_merged) return PRRUN_MERGED;
+  return is_untouched(facts) ? PRRUN_MERGE : PRRUN_GATE;
+}
+function stop_head_of(read, issue) {
+  const hold = run_halfrun_resume.hold_of(read);
+  return hold?.issue === issue ? hold.prrun_stop_head : void 0;
+}
+async function read_merge_state() {
+  return await git_gh_command.pr_get_merge_state(await git_branch.current());
+}
+async function read_facts(stop_head) {
+  const [state, head, is_dirty] = await Promise.all([
+    read_merge_state(),
+    git_command.head_commit(),
+    run_hold.is_tree_dirty()
+  ]);
+  return {
+    is_merged: state?.is_merged === true,
+    stop_head,
+    head,
+    pr_head: state?.head_sha,
+    is_dirty
+  };
+}
+async function resume_token(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0) return void 0;
+  const stop_head = stop_head_of(run_hold.read_hold(target), issue);
+  return stop_head === void 0 ? void 0 : decide(await read_facts(stop_head));
+}
+async function adopt(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0 || stop_head_of(run_hold.read_hold(target), issue) === void 0) {
+    return false;
+  }
+  return run_halfrun_resume.take_over(target, issue);
+}
+async function mark_stop_at(target, issue) {
+  const head = await git_command.head_commit();
+  return run_halfrun_resume.mark_stop_at(target, issue, { prrun_stop_head: head });
+}
+var run_prrun_resume = {
+  PRRUN_GATE,
+  PRRUN_MERGE,
+  PRRUN_MERGED,
+  adopt,
+  decide,
+  mark_stop_at,
+  resume_token,
+  stop_head_of
+};
+
+// scripts/run/hold/run-hold-adopt.ts
+var ADOPTED = "adopted";
+var NO_RECORD = "none";
+var FOREIGN = "foreign";
+var UNREADABLE = "unreadable";
+function rekey(target, issue) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  const hold = run_halfrun_resume.hold_of(read);
+  if (hold === void 0) return NO_RECORD;
+  if (hold.issue !== run_hold.UNNUMBERED_ISSUE && hold.issue !== issue) return FOREIGN;
+  stamp_file.write_stamp(target, { ...hold, issue });
+  return ADOPTED;
+}
+function no_record_message(issue) {
+  return `run:hold --adopt: this tree holds no record to adopt \u2014 claim it with \`pnpm josh run:hold ${issue}\`.`;
+}
+function foreign_message(issue) {
+  return `run:hold --adopt: this tree is held for another issue, so it is not handed to issue ${issue}; \`--adopt\` only re-keys a \`new\` run's unnumbered record.`;
+}
+async function adopt2(target, issue) {
+  const result = rekey(target, issue);
+  if (result === ADOPTED) await run_label.mark(issue);
+  return result;
+}
+var run_hold_adopt = {
+  ADOPTED,
+  NO_RECORD,
+  UNREADABLE,
+  adopt: adopt2,
+  foreign_message,
+  no_record_message
+};
+
+// scripts/run/hold/run-stop-notify.ts
+var TITLE_PLACEHOLDER = "<title>";
+var PR_PLACEHOLDER = "<pr-url>";
+var HALFRUN = "halfrun";
+var PRRUN = "prrun";
+function reference_of(facts) {
+  return issue_cite.plain_for("telegram", facts.issue);
+}
+function commit_title(facts) {
+  return shell_quote.single_quoted(`${facts.title ?? TITLE_PLACEHOLDER} ${reference_of(facts)}`);
+}
+function with_urls(values, facts) {
+  const with_issue = facts.issue_url === void 0 ? values : { ...values, "issue-url": facts.issue_url };
+  return facts.pr_url === void 0 ? with_issue : { ...with_issue, "pr-url": facts.pr_url };
+}
+function halfrun_values(facts) {
+  const title = commit_title(facts);
+  const body = [
+    "halfrun ready for manual verification",
+    run_stage.next_line(HALFRUN, facts.issue),
+    `Without an agent: pnpm josh git -y ${title} && pnpm josh followup ${title}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `Verify by hand, then prrun ${reference_of(facts)}`,
+    alternative: [`fullrun ${reference_of(facts)}`]
+  };
+  return with_urls(values, facts);
+}
+function human_review_values(facts, directory) {
+  const body = [
+    "needs-human-review: implemented and gated, stopped before the commit",
+    run_stage.next_line(HALFRUN, facts.issue),
+    `Working tree: ${directory}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `Review the working tree, then prrun ${reference_of(facts)}`,
+    alternative: [`fullrun ${reference_of(facts)}`]
+  };
+  return with_urls(values, facts);
+}
+function prrun_values(facts) {
+  const body = [
+    `prrun ready to merge: ${facts.pr_url ?? PR_PLACEHOLDER}`,
+    run_stage.next_line(PRRUN, facts.issue),
+    `After a manual merge, without an agent: pnpm josh followup ${commit_title(facts)}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `fullrun ${reference_of(facts)}`,
+    alternative: ["Merge by hand, then pnpm josh followup"]
+  };
+  return with_urls(values, facts);
+}
+async function issue_facts(issue) {
+  const slug = await git_gh_repo.repo_get_name_with_owner();
+  const title = await git_gh_issue_read.issue_get_title(issue);
+  return {
+    issue,
+    title,
+    issue_url: slug === void 0 ? void 0 : issue_cite.issue_url(slug, issue)
+  };
+}
+async function prrun_facts(issue) {
+  const pr_url = await git_gh_pr_read.pr_get_url(await git_command.branch());
+  return { ...await issue_facts(issue), pr_url };
+}
+async function send_composed(target, compose) {
+  const { values, title } = await compose();
+  const titled = title === void 0 ? values : { ...values, "issue-title": title };
+  await stdout_on_stderr.run(async () => {
+    await telegram_test.send_values(titled);
+  });
+  run_hold_session.mark_notified(target);
+}
+async function send(target, compose) {
+  try {
+    await send_composed(target, compose);
+  } catch (error) {
+    console.error(`\u26A0\uFE0F  run:hold could not send the stop confirmation: ${String(error)}`);
+  }
+}
+async function send_halfrun(target, issue) {
+  await send(target, async () => {
+    const facts = await issue_facts(issue);
+    return { values: halfrun_values(facts), title: facts.title };
+  });
+}
+async function send_prrun(target, issue) {
+  await send(target, async () => {
+    const facts = await prrun_facts(issue);
+    return { values: prrun_values(facts), title: facts.title };
+  });
+}
+async function send_human_review(target, issue) {
+  await send(target, async () => {
+    const facts = await issue_facts(issue);
+    const directory = await git_command.repository_root();
+    return { values: human_review_values(facts, directory), title: facts.title };
+  });
+}
+var run_stop_notify = {
+  halfrun_values,
+  human_review_values,
+  prrun_values,
+  send_halfrun,
+  send_human_review,
+  send_prrun
+};
+
+// scripts/run/hold/run-hold-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var RELEASE_FLAG = "--release";
+var FORCE_FLAG = "--force";
+var FULLRUN_FLAG = "--fullrun";
+var HALFRUN_STOP_FLAG = "--halfrun-stop";
+var HALFRUN_ROUND_FLAG = "--halfrun-round";
+var PRRUN_STOP_FLAG = "--prrun-stop";
+var HUMAN_REVIEW_STOP_FLAG = "--human-review-stop";
+var ADOPT_FLAG = "--adopt";
+var MAX_CLAIM_ARGUMENTS = 2;
+var USAGE = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --halfrun-round | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]";
+var COMMAND = "run:hold";
+var HOLD_VERDICT = "hold";
+var BUSY_VERDICT = "busy";
+var UNKNOWN_VERDICT = "unknown";
+var RELEASED_VERDICT = "released";
+var NONE_VERDICT = "none";
+var HELD_VERDICT = "held";
+var E2E_OWED_VERDICT = "e2e-owed";
+var FORCE_RELEASE_KIND = "force-release";
+var HALFRUN_STOP_KIND = "halfrun-stop";
+var HUMAN_REVIEW_STOP_KIND = "human-review-stop";
+var PRRUN_STOP_KIND = "prrun-stop";
+var ADOPT_KIND = "adopt";
+var HALFRUN_ROUND_KIND = "halfrun-round";
+var STOP_KINDS = /* @__PURE__ */ new Set([
+  HALFRUN_STOP_KIND,
+  HUMAN_REVIEW_STOP_KIND,
+  PRRUN_STOP_KIND
+]);
+function is_stop_request(request) {
+  return STOP_KINDS.has(request.kind);
+}
+var TAKE_OVER_KINDS = /* @__PURE__ */ new Set([ADOPT_KIND, HALFRUN_ROUND_KIND]);
+function is_take_over_request(request) {
+  return TAKE_OVER_KINDS.has(request.kind);
+}
+var FORCE_RELEASE_REQUEST = { kind: FORCE_RELEASE_KIND };
+function release_request(claimant) {
+  return { kind: "release", claimant };
+}
+var STOP_KIND_BY_FLAG = /* @__PURE__ */ new Map([
+  [HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
+  [HUMAN_REVIEW_STOP_FLAG, HUMAN_REVIEW_STOP_KIND],
+  [PRRUN_STOP_FLAG, PRRUN_STOP_KIND]
+]);
+function numbered_claim(issue, flag) {
+  if (flag === void 0) return { kind: "claim", issue };
+  const stop_kind = STOP_KIND_BY_FLAG.get(flag);
+  if (stop_kind !== void 0) return { kind: stop_kind, issue };
+  if (flag === HALFRUN_ROUND_FLAG) return { kind: HALFRUN_ROUND_KIND, issue };
+  return flag === FULLRUN_FLAG ? { kind: "claim", issue, is_fullrun: true } : void 0;
+}
+function parse_claim(argv) {
+  const [first, flag] = argv;
+  if (first === void 0) return { kind: "claim", issue: run_hold.UNNUMBERED_ISSUE };
+  if (argv.length > MAX_CLAIM_ARGUMENTS || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
+    return void 0;
+  }
+  return numbered_claim(first, flag);
+}
+function parse_release_argument(first) {
+  if (first === FORCE_FLAG) return FORCE_RELEASE_REQUEST;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(first) ? release_request(first) : void 0;
+}
+function parse_release(argv) {
+  const [first] = argv;
+  if (first === void 0) return release_request(run_hold.UNNUMBERED_ISSUE);
+  return argv.length > 1 ? void 0 : parse_release_argument(first);
+}
+function parse_adopt(argv) {
+  const [issue] = argv;
+  if (issue === void 0 || argv.length > 1) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? { kind: ADOPT_KIND, issue } : void 0;
+}
+function parse_request(argv) {
+  if (argv[0] === RELEASE_FLAG) return parse_release(argv.slice(1));
+  if (argv[0] === ADOPT_FLAG) return parse_adopt(argv.slice(1));
+  return parse_claim(argv);
+}
+function report(message, verdict, code) {
+  console.error(message);
+  console.info(verdict);
+  return code;
+}
+function report_busy(message) {
+  return report(message, BUSY_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_hold() {
+  console.info(HOLD_VERDICT);
+  return SUCCESS_EXIT_CODE;
+}
+function take_free_tree(target, request) {
+  const is_taken = run_hold.create_hold(target, request.issue, /* @__PURE__ */ new Date(), request.is_fullrun);
+  if (is_taken) return report_hold();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+function replace_stale(target, request, hold) {
+  console.error(run_hold.stale_message(hold));
+  run_hold.release_hold(target);
+  return take_free_tree(target, request);
+}
+function take_tree(target, request, read) {
+  if (read.kind === "held") return report_hold();
+  return read.kind === "stale" ? replace_stale(target, request, read.hold) : take_free_tree(target, request);
+}
+function report_preflight(decision) {
+  console.error(`${decision.reason}
+${decision.advice}`);
+  console.info(decision.verdict);
+  return SUCCESS_EXIT_CODE;
+}
+async function preflight_gate(issue, is_linked) {
+  if (is_linked || issue === run_hold.UNNUMBERED_ISSUE) return void 0;
+  const decision = await run_preflight.check(issue);
+  if (decision.verdict !== run_preflight.CLEAN_VERDICT) return report_preflight(decision);
+  if (decision.advice === run_preflight.RESUME_ADVICE) {
+    console.error(`${decision.reason}
+${decision.advice}`);
+  }
+  return void 0;
+}
+async function claim(target, request, is_linked) {
+  const gate = await run_ship_lap.timed(
+    "preflight",
+    async () => await preflight_gate(request.issue, is_linked)
+  );
+  if (gate !== void 0) return gate;
+  const read = run_hold.read_hold(target);
+  const blocked = await run_hold_block.blocking_message(read, request.issue);
+  if (blocked !== void 0) return report_busy(blocked);
+  const code = await run_ship_lap.timed("take_tree", async () => take_tree(target, request, read));
+  if (code === SUCCESS_EXIT_CODE) run_maintenance.sweep();
+  return code;
+}
+function remove_record(target, was_present) {
+  run_hold.release_hold(target);
+  console.info(was_present ? RELEASED_VERDICT : NONE_VERDICT);
+  return SUCCESS_EXIT_CODE;
+}
+function report_held(hold) {
+  return report(run_hold.foreign_release_message(hold), HELD_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_unreadable_record() {
+  return report(run_hold.unreadable_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function release_record(target, claimant) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "free") return remove_record(target, false);
+  if (read.kind === "unreadable") return report_unreadable_record();
+  if (!run_hold.is_own_hold(read.hold, claimant)) return report_held(read.hold);
+  return remove_record(target, true);
+}
+async function release(target, claimant) {
+  const code = release_record(target, claimant);
+  const is_own_end = code === SUCCESS_EXIT_CODE && claimant !== run_hold.UNNUMBERED_ISSUE;
+  if (is_own_end) await run_label.unmark(claimant);
+  return code;
+}
+function force_release(target) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "held" || read.kind === "stale") {
+    console.error(run_hold.forced_release_message(read.hold));
+  }
+  return remove_record(target, read.kind !== "free");
+}
+function report_unknown() {
+  return report(run_hold.unknown_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_usage() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE;
+}
+var SEND_BY_KIND = {
+  [HALFRUN_STOP_KIND]: run_stop_notify.send_halfrun,
+  [HUMAN_REVIEW_STOP_KIND]: run_stop_notify.send_human_review,
+  [PRRUN_STOP_KIND]: run_stop_notify.send_prrun
+};
+async function marked_stop(target, request) {
+  if (request.kind === HUMAN_REVIEW_STOP_KIND) {
+    await lane_state.record_change({
+      issue: request.issue,
+      state: "human-review",
+      command: "run:hold --human-review-stop"
+    });
+  }
+  await SEND_BY_KIND[request.kind](target, request.issue);
+  return report_hold();
+}
+async function e2e_refusal(request) {
+  if (request.kind === PRRUN_STOP_KIND || await test_e2e_stamp.is_current_tree()) return void 0;
+  return report(
+    "run:hold: `pnpm josh test:e2e` has not answered green on this tree \u2014 run it, then mark the stop again.",
+    E2E_OWED_VERDICT,
+    FAILURE_EXIT_CODE
+  );
+}
+async function mark_stop(target, request) {
+  const refusal = await e2e_refusal(request);
+  if (refusal !== void 0) return refusal;
+  const mark = request.kind === PRRUN_STOP_KIND ? await run_prrun_resume.mark_stop_at(target, request.issue) : run_halfrun_resume.mark_stop_at(target, request.issue);
+  if (mark === run_halfrun_resume.MARKED) return await marked_stop(target, request);
+  if (mark === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+async function adopt3(target, issue) {
+  const result = await run_hold_adopt.adopt(target, issue);
+  if (result === run_hold_adopt.ADOPTED) return report_hold();
+  if (result === run_hold_adopt.UNREADABLE) return report_unreadable_record();
+  if (result === run_hold_adopt.NO_RECORD) {
+    return report(run_hold_adopt.no_record_message(issue), NONE_VERDICT, FAILURE_EXIT_CODE);
+  }
+  return report(run_hold_adopt.foreign_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+async function reopen_round(target, issue) {
+  const result = await run_halfrun_resume.reopen(target, issue);
+  if (result === run_halfrun_resume.MARKED) return report_hold();
+  if (result === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report(run_halfrun_resume.no_stop_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+async function take_over(target, request) {
+  const { kind, issue } = request;
+  return kind === ADOPT_KIND ? await adopt3(target, issue) : await reopen_round(target, issue);
+}
+async function dispatch(request, target, is_linked) {
+  if (request.kind === "claim") return await claim(target, request, is_linked);
+  if (is_take_over_request(request)) return await take_over(target, request);
+  if (is_stop_request(request)) return await mark_stop(target, request);
+  if (request.kind === FORCE_RELEASE_KIND) return force_release(target);
+  return await release(target, request.claimant);
+}
+async function answer(request) {
+  const directory = await run_cli_fault.directory_of(COMMAND, run_hold.worktree_directory);
+  if (directory === void 0) return report_unknown();
+  const is_linked = await run_hold.is_linked_worktree();
+  return await dispatch(request, run_hold.hold_path(directory), is_linked);
+}
+async function run2(argv) {
+  const request = parse_request(argv);
+  if (request === void 0) return report_usage();
+  try {
+    return await answer(request);
+  } catch (error) {
+    return report(run_cli_fault.message(COMMAND, error), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+  }
+}
+var run_hold_cli = {
+  BUSY_VERDICT,
+  HELD_VERDICT,
+  HOLD_VERDICT,
+  NONE_VERDICT,
+  RELEASED_VERDICT,
+  UNKNOWN_VERDICT,
+  USAGE,
+  parse_request,
+  run: run2
+};
+
+export {
+  stdout_on_stderr,
+  run_prrun_resume,
+  run_hold_cli
+};