@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-VK6D5CWA.js

@@ -1,161 +0,0 @@
-import {
-  epic_blocked_by
-} from "./chunk-KZ7HD37E.js";
-import {
-  stash_push_cli
-} from "./chunk-TR7WWYD5.js";
-import {
-  main_merge_guard
-} from "./chunk-P4D5RESF.js";
-import {
-  run_hold_cli
-} from "./chunk-4ZQM4I7R.js";
-import {
-  run_pause_comment
-} from "./chunk-KCFOP5RI.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/run/pause/run-set-aside-commit.ts
-var COMMAND = "run:pause";
-var RERUN = "the command that paused (`run:pause`, `run:split`)";
-var COMMITTED_VERDICT = "committed";
-var CLEAN_VERDICT = "clean";
-var ALREADY = "already";
-async function is_lane(issue) {
-  return await git_command.branch() === lane_paths.lane_branch(issue);
-}
-function message_of(stash_message) {
-  return `wip: ${stash_message}`;
-}
-async function is_committed(stash_message) {
-  return await git_spawn.read(["log", "-1", "--format=%s"]) === message_of(stash_message);
-}
-async function commit(stash_message) {
-  if (await is_committed(stash_message)) return ALREADY;
-  const unmerged = await git_stash.unmerged_paths();
-  if (unmerged.length > 0) {
-    throw new Error(main_merge_guard.unresolved_message(COMMAND, unmerged, RERUN));
-  }
-  if (!await git_stash.has_stashable_changes()) return CLEAN_VERDICT;
-  await git_spawn.read(["add", "-A", "--", ":/"]);
-  await git_spawn.read(["commit", "--no-verify", "-m", message_of(stash_message)]);
-  return COMMITTED_VERDICT;
-}
-var run_set_aside_commit = { is_lane, is_committed, message_of, commit };
-
-// scripts/run/pause/run-set-aside.ts
-var SUCCESS_EXIT_CODE = 0;
-var ALREADY2 = "already";
-async function is_stashed(request) {
-  return git_stash.select(await git_stash.list(), request.stash_message).kind !== "none";
-}
-async function stash(request) {
-  if (await is_stashed(request)) return ALREADY2;
-  return await stash_push_cli.set_aside({ message: request.stash_message, dir: void 0 });
-}
-async function is_committed_aside(request) {
-  if (request.is_handed_off === true) return false;
-  return await run_set_aside_commit.is_lane(request.issue);
-}
-async function set_aside(request) {
-  if (!await is_committed_aside(request)) return await stash(request);
-  return await run_set_aside_commit.commit(request.stash_message);
-}
-var NOTHING_SET_ASIDE = "- The tree held no uncommitted work, so nothing was set aside.";
-function committed_line(request) {
-  const message = run_set_aside_commit.message_of(request.stash_message);
-  return `- The work in progress was committed on the lane branch as \`${message}\`. To resume, run \`pnpm josh main:merge\` on the lane and continue.`;
-}
-function stashed_line(request) {
-  return `- The work in progress was stashed. After \`pnpm josh ms\`, recover it with \`pnpm josh stash:pop "${request.stash_message}"\`.`;
-}
-async function work_line(request) {
-  if (await is_committed_aside(request)) {
-    const is_committed2 = await run_set_aside_commit.is_committed(request.stash_message);
-    return is_committed2 ? committed_line(request) : NOTHING_SET_ASIDE;
-  }
-  return await is_stashed(request) ? stashed_line(request) : NOTHING_SET_ASIDE;
-}
-async function comment(request) {
-  if (await run_pause_comment.has_comment(request)) return ALREADY2;
-  const body = [request.headline, await work_line(request), request.marker].join("\n");
-  return await git_gh_issue_write.issue_comment(request.issue, body);
-}
-async function release(issue) {
-  const code = await run_hold_cli.run(["--release", issue]);
-  if (code !== SUCCESS_EXIT_CODE) throw new Error("`run:release` refused");
-  return "released";
-}
-async function attempt(act) {
-  try {
-    return { detail: await act() };
-  } catch (error) {
-    return { reason: error_text.message_of(error) };
-  }
-}
-async function run_steps(steps) {
-  const done = [];
-  for (const [step, act] of steps) {
-    const outcome = await attempt(act);
-    if ("reason" in outcome) return { kind: "failed", step, reason: outcome.reason, done };
-    done.push({ step, detail: outcome.detail });
-  }
-  return { kind: "done", done };
-}
-function steps_of(request, between = []) {
-  return [
-    ["set-aside", async () => await set_aside(request)],
-    ["comment", async () => await comment(request)],
-    ...between,
-    ["release", async () => await release(request.issue)]
-  ];
-}
-var run_set_aside = { steps_of, run_steps };
-
-// scripts/run/pause/run-pause.ts
-function aside_of(request) {
-  const issue = issue_cite.plain_for("program", request.issue);
-  const prerequisite = issue_cite.plain_for("program", request.prerequisite);
-  return {
-    issue: request.issue,
-    stash_message: `run:pause: ${issue} waits on ${prerequisite}`,
-    marker: `${run_pause_comment.marker_of(request.issue)}${prerequisite} -->`,
-    headline: `Paused: ${prerequisite} has to land first.`
-  };
-}
-var NO_STEPS = { before: [], after: [] };
-async function pause(request, around = NO_STEPS) {
-  const steps = run_set_aside.steps_of(aside_of(request), [
-    ...around.before,
-    ["blocked-by", async () => await epic_blocked_by.record(request)],
-    ...around.after
-  ]);
-  const result = await run_set_aside.run_steps(steps);
-  return result.kind === "done" ? { kind: "paused", done: result.done } : result;
-}
-var run_pause = { pause, aside_of };
-
-export {
-  run_set_aside,
-  run_pause
-};

package/dist/commands/chunk-VOF3N4WO.js

@@ -1,114 +0,0 @@
-import {
-  issue_report_failures,
-  issue_state_cli
-} from "./chunk-BRHPRDDV.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  issue_read
-} from "./chunk-2BB5ZR2F.js";
-import {
-  gh_rate_limit
-} from "./chunk-TVZXG4Y4.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-
-// scripts/issue/issue-read-cli.ts
-var FAILURE_EXIT_CODE = 1;
-var USAGE = "Usage: josh issue:read <issue-number> [<issue-number> ...] [--repo <owner/repo>]";
-var BLOCK_SEPARATOR = "\n\n---\n\n";
-var ISSUE_FIELDS = `title,state,body,${gh_author_association.AUTHOR_FIELDS}`;
-var FAILURE_TERMS = { success_kind: "issue", misreading: "the issue is empty" };
-function parse_numbers(argv) {
-  const numbers = argv.filter((argument) => issue_number_shape.is_issue_number(argument));
-  if (numbers.length === 0 || numbers.length !== argv.length) return void 0;
-  return [...new Set(numbers)];
-}
-function parse_request(argv) {
-  const parsed = cli_flags.arguments_of(argv, issue_state_cli.REPO_OPTIONS);
-  if (parsed === void 0) return void 0;
-  const repo = issue_state_cli.read_repo(parsed.values.repo);
-  const issue_numbers = parse_numbers(parsed.positionals);
-  if (repo === void 0 || issue_numbers === void 0) return void 0;
-  return { issue_numbers, ...repo };
-}
-async function to_failure_result(failure) {
-  if (failure.kind === "missing" || failure.detail === void 0) return { kind: failure.kind };
-  return { kind: failure.kind, hint: await gh_rate_limit.failure_hint(failure.detail) };
-}
-async function read_issue(issue_number, repo) {
-  const { read, comments_json } = await git_gh_command.issue_read_with_comments(
-    issue_number,
-    ISSUE_FIELDS,
-    repo
-  );
-  if (read.kind !== "read") return await to_failure_result(read);
-  const fields = await issue_read.parse_issue_fields(read.json, repo);
-  if (fields === void 0) return { kind: "unreadable" };
-  const comments = await issue_read.parse_comments(comments_json, repo);
-  return { kind: "issue", content: { fields, comments } };
-}
-function has_trusted_comment(comments) {
-  if (comments?.some((comment) => comment.is_trusted === true) === true) return true;
-  if (comments === void 0 || comments.some((comment) => comment.is_trusted === void 0)) {
-    return void 0;
-  }
-  return false;
-}
-async function read_block(issue_number) {
-  const result = await read_issue(issue_number);
-  if (result.kind !== "issue") return { kind: result.kind };
-  const { fields, comments } = result.content;
-  const trust = {
-    is_body_trusted: fields.is_body_trusted,
-    has_trusted_comment: has_trusted_comment(comments)
-  };
-  return { kind: "ok", block: issue_read.format_issue(issue_number, fields, comments), trust };
-}
-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 issue_blocks(report) {
-  if (report.result.kind !== "issue") return [];
-  const { fields, comments } = report.result.content;
-  return [issue_read.format_issue(report.issue_number, fields, comments)];
-}
-async function run(argv) {
-  const request = parse_request(argv);
-  if (request === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  const reports = await read_all(request);
-  issue_report_failures.print_blocks(
-    reports.flatMap((report) => issue_blocks(report)),
-    BLOCK_SEPARATOR,
-    `issue:read ${request.issue_numbers.join(" ")}`
-  );
-  return issue_report_failures.report_failures(reports, FAILURE_TERMS);
-}
-var issue_read_cli = {
-  USAGE,
-  parse_numbers,
-  parse_request,
-  read_block,
-  read_issue,
-  run
-};
-
-export {
-  issue_read_cli
-};

package/dist/commands/chunk-VQVPAVQ3.js

@@ -1,45 +0,0 @@
-import {
-  run_cut
-} from "./chunk-DYZOOWVW.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.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
-};

package/dist/commands/chunk-VV4TQYGD.js

@@ -1,38 +0,0 @@
-import {
-  lane_await
-} from "./chunk-IB5TT73I.js";
-import {
-  PROCESS_NONE
-} from "./chunk-3AEDZZNL.js";
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/lane/lane-vacant.ts
-async function has_no_commits(lane) {
-  try {
-    const base = await git_command.default_branch_reference();
-    return await git_command.commit_count_beyond(base, lane.branch) === 0;
-  } catch {
-    return false;
-  }
-}
-function is_occupied(lane) {
-  return lane.is_stranded || lane_await.process_trace_default(lane.issue) !== PROCESS_NONE;
-}
-async function is_vacant(lane) {
-  if (is_occupied(lane) || await run_hold.is_tree_dirty(lane.directory)) return false;
-  return await has_no_commits(lane);
-}
-async function vacant_issues(lanes) {
-  const answers = await Promise.all(lanes.map(async (lane) => await is_vacant(lane)));
-  return lanes.filter((_lane, index) => answers[index] === true).map((lane) => lane.issue);
-}
-var lane_vacant = { is_vacant, vacant_issues };
-
-export {
-  lane_vacant
-};

package/dist/commands/chunk-W3FX7FYN.js

@@ -1,84 +0,0 @@
-import {
-  ls_remote_branch_arguments
-} from "./chunk-ZBFNQUY7.js";
-import {
-  repository_lock
-} from "./chunk-P4KIQRSL.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  PORCELAIN_FLAG
-} from "./chunk-B5GXZK3E.js";
-import {
-  INSTALL_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/git/git-worktree.ts
-var WORKTREE = "worktree";
-var ORIGIN = "origin";
-var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
-var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
-async function locked(arguments_, timeout_ms) {
-  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
-  const output = await repository_lock.with_lock(
-    async () => await git_spawn.read(arguments_, timeout_ms),
-    target,
-    WORKTREE_LOCK_MAX_WAIT_MS
-  );
-  if (output === void 0) {
-    throw new Error(
-      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
-    );
-  }
-  return output;
-}
-async function worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
-}
-async function worktree_add(directory, branch_name, start_point) {
-  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
-  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
-}
-async function set_upstream(branch_name) {
-  await locked(["config", `branch.${branch_name}.remote`, ORIGIN]);
-  await locked(["config", `branch.${branch_name}.merge`, `refs/heads/${branch_name}`]);
-}
-async function worktree_add_detached(directory, commit) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
-}
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
-}
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
-}
-async function ls_remote_branch(branch_name) {
-  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
-}
-async function branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
-}
-async function is_linked() {
-  const [own, common] = await git_command.git_directories();
-  return own !== common;
-}
-var git_worktree = {
-  is_linked,
-  branch_delete,
-  ls_remote_branch,
-  set_upstream,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
-};
-
-export {
-  git_worktree
-};

package/dist/commands/chunk-W7DRUOF7.js

@@ -1,122 +0,0 @@
-import {
-  issue_auto_ok
-} from "./chunk-QGATHT4S.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  issue_watch_diff
-} from "./chunk-RW64VHEB.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  issue_label_schema
-} from "./chunk-34DND4BA.js";
-import {
-  AUTO_OK_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  read_json_listing
-} from "./chunk-XDF25GSU.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-
-// scripts/auto-ok/auto-ok-judge-read.ts
-import { z } from "zod";
-
-// scripts/auto-ok/auto-ok-judge.ts
-import { createHash } from "node:crypto";
-var MARKER_PREFIX = "<!-- josh:auto-ok-judged v=2 body=";
-var MARKER_SUFFIX = " -->";
-var MARKER_PATTERN = /<!-- josh:auto-ok-judged v=2 body=(?<digest>[\da-f]+) -->/u;
-var DIGEST_LENGTH = 16;
-var CRLF = "\r\n";
-var LF = "\n";
-function is_candidate(issue) {
-  if (!issue.is_trusted || has_label_name(issue.labels, AUTO_OK_LABEL)) return false;
-  return issue_auto_ok.exclusion_of(issue.labels) === void 0;
-}
-function body_digest(body) {
-  const normalized = body.split(CRLF).join(LF);
-  return createHash("sha256").update(normalized).digest("hex").slice(0, DIGEST_LENGTH);
-}
-function digest_of(comment) {
-  if (!comment.is_trusted) return void 0;
-  return MARKER_PATTERN.exec(comment.body)?.groups?.["digest"];
-}
-function is_person_comment(comment) {
-  return comment.is_trusted === true && !comment.is_automated;
-}
-function is_judged(body, comments) {
-  const judgement = comments.findLast((comment) => digest_of(comment) !== void 0);
-  if (judgement === void 0 || digest_of(judgement) !== body_digest(body)) return false;
-  return comments.every((comment) => comment.id <= judgement.id || !is_person_comment(comment));
-}
-function comment_of(decision, body) {
-  const marker = `${MARKER_PREFIX}${body_digest(body)}${MARKER_SUFFIX}`;
-  return `${issue_auto_ok.line_of(decision)}${LF}${LF}${marker}`;
-}
-var auto_ok_judge = { comment_of, is_candidate, is_judged };
-
-// scripts/auto-ok/auto-ok-judge-read.ts
-var LISTING_LIMIT = 200;
-var COMMENT_READ_WIDTH = 4;
-var row_schema = z.looseObject({
-  number: z.number(),
-  title: z.string(),
-  body: z.string().nullish(),
-  labels: z.array(issue_label_schema),
-  updatedAt: z.string(),
-  author_association: z.string().nullish(),
-  user: z.looseObject({ login: z.string() }).nullish()
-});
-async function to_row(raw) {
-  return {
-    number: raw.number,
-    title: raw.title,
-    body: raw.body ?? "",
-    labels: raw.labels.map((label) => label.name),
-    updated_at: raw.updatedAt,
-    is_trusted: await gh_author_association.is_trusted({
-      login: raw.user?.login,
-      association: raw.author_association
-    })
-  };
-}
-async function read_candidates() {
-  const { json } = await git_gh_command.issue_list_open_for_judgement(LISTING_LIMIT);
-  if (json === void 0) return void 0;
-  const listing = read_json_listing(json, row_schema);
-  if (listing.kind !== "read") return void 0;
-  const rows = await Promise.all(listing.rows.map(async (raw) => await to_row(raw)));
-  return rows.filter((row) => auto_ok_judge.is_candidate(row));
-}
-async function owes_judgement(row, cache) {
-  if (cache.get(row.number) === row.updated_at) return false;
-  const comments = await issue_watch_diff.parse_comments(
-    await git_gh_command.issue_list_comments(String(row.number))
-  );
-  if (comments === void 0) return false;
-  if (!auto_ok_judge.is_judged(row.body, comments)) return true;
-  cache.set(row.number, row.updated_at);
-  return false;
-}
-async function owed(cache = /* @__PURE__ */ new Map()) {
-  const candidates = await read_candidates();
-  if (candidates === void 0) return void 0;
-  const owing = await bounded_pool.bounded_map(
-    candidates,
-    COMMENT_READ_WIDTH,
-    async (row) => await owes_judgement(row, cache)
-  );
-  return candidates.filter((_row, index) => owing[index] === true);
-}
-var auto_ok_judge_read = { owed };
-
-export {
-  auto_ok_judge,
-  auto_ok_judge_read
-};