@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-H6MHUR2Y.js

@@ -0,0 +1,114 @@
+import {
+  issue_report_failures,
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  issue_read
+} from "./chunk-TR6NTNWR.js";
+import {
+  gh_rate_limit
+} from "./chunk-W4R6ZBLO.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.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-H6TBBVC2.js

@@ -0,0 +1,73 @@
+import {
+  git_worktree
+} from "./chunk-2AH73ZTW.js";
+
+// scripts/git/base-tree.ts
+import { rmSync } from "node:fs";
+import { copyFile, mkdir, mkdtemp, rm, symlink } from "node:fs/promises";
+import { constants, tmpdir } from "node:os";
+import path from "node:path";
+var TREE_NAME = "tree";
+var NODE_MODULES = "node_modules";
+var STOP_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+var SIGNAL_EXIT_BASE = 128;
+var live_parents = /* @__PURE__ */ new Set();
+async function prepare(tree, commit) {
+  await git_worktree.worktree_add_detached(tree, commit);
+  await symlink(path.resolve(NODE_MODULES), path.join(tree, NODE_MODULES), "dir");
+}
+async function remove(base_tree2) {
+  try {
+    await git_worktree.worktree_remove(base_tree2.tree);
+  } catch {
+  }
+  await rm(base_tree2.parent, { force: true, recursive: true });
+  try {
+    await git_worktree.worktree_prune();
+  } catch {
+  }
+}
+function remove_live_trees(signal) {
+  for (const parent of live_parents) rmSync(parent, { force: true, recursive: true });
+  process.exit(SIGNAL_EXIT_BASE + constants.signals[signal]);
+}
+function track(parent) {
+  if (live_parents.size === 0) {
+    for (const signal of STOP_SIGNALS) process.on(signal, remove_live_trees);
+  }
+  live_parents.add(parent);
+}
+function untrack(parent) {
+  live_parents.delete(parent);
+  if (live_parents.size > 0) return;
+  for (const signal of STOP_SIGNALS) process.off(signal, remove_live_trees);
+}
+async function with_tree(prefix, commit, use) {
+  const parent = await mkdtemp(path.join(tmpdir(), prefix));
+  const base_tree2 = { parent, tree: path.join(parent, TREE_NAME) };
+  track(parent);
+  try {
+    await prepare(base_tree2.tree, commit);
+    return await use(base_tree2);
+  } finally {
+    await remove(base_tree2);
+    untrack(parent);
+  }
+}
+async function copy_one(tree, file) {
+  const target = path.join(tree, file);
+  await mkdir(path.dirname(target), { recursive: true });
+  await copyFile(file, target);
+}
+async function copy_in(tree, files) {
+  await Promise.all(
+    files.map(async (file) => {
+      await copy_one(tree, file);
+    })
+  );
+}
+var base_tree = { NODE_MODULES, copy_in, with_tree };
+
+export {
+  base_tree
+};

package/dist/commands/chunk-HF52YP56.js

@@ -0,0 +1,178 @@
+import {
+  lane_install
+} from "./chunk-LAQZJX5C.js";
+import {
+  USAGE_ERROR_EXIT_CODE,
+  composite_arguments
+} from "./chunk-RSSJWMQS.js";
+import {
+  git_worktree
+} from "./chunk-2AH73ZTW.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/git/gone-branch.ts
+var FIELD_SEPARATOR = "	";
+var GONE_TRACK = "[gone]";
+var BRANCH_NAME = "%(refname:lstrip=2)";
+var RECORD_FORMAT = [BRANCH_NAME, "%(upstream:track)", "%(upstream)", "%(worktreepath)"].join(
+  FIELD_SEPARATOR
+);
+var LOCAL_HEADS = "refs/heads";
+var REMOTE_HEADS = "refs/remotes/";
+var FOR_EACH_REF = "for-each-ref";
+var NAME_FIELD = 0;
+var TRACK_FIELD = 1;
+var UPSTREAM_FIELD = 2;
+var WORKTREE_FIELD = 3;
+function non_empty_lines(output) {
+  return output.split("\n").filter((line) => line.trim() !== "");
+}
+function parse_record(line) {
+  const fields = line.split(FIELD_SEPARATOR);
+  return {
+    name: fields[NAME_FIELD] ?? "",
+    is_gone: fields[TRACK_FIELD] === GONE_TRACK && (fields[UPSTREAM_FIELD] ?? "").startsWith(REMOTE_HEADS),
+    is_checked_out: (fields[WORKTREE_FIELD] ?? "") !== ""
+  };
+}
+function parse_records(output) {
+  return non_empty_lines(output).map((line) => parse_record(line));
+}
+function select_prunable(records, merged, default_branch) {
+  return records.filter((record2) => record2.is_gone && !record2.is_checked_out && merged.has(record2.name)).map((record2) => record2.name).filter((name) => name !== default_branch);
+}
+async function read_candidates(default_branch) {
+  const records = await git_spawn.read([FOR_EACH_REF, `--format=${RECORD_FORMAT}`, LOCAL_HEADS]);
+  const merged = await git_spawn.read([
+    FOR_EACH_REF,
+    `--merged=refs/heads/${default_branch}`,
+    `--format=${BRANCH_NAME}`,
+    LOCAL_HEADS
+  ]);
+  return select_prunable(parse_records(records), new Set(non_empty_lines(merged)), default_branch);
+}
+async function delete_each(names) {
+  const result = { deleted: [], failed: [] };
+  for (const name of names) {
+    try {
+      await git_spawn.read(["branch", "-d", name]);
+      result.deleted.push(name);
+    } catch {
+      result.failed.push(name);
+    }
+  }
+  return result;
+}
+async function prune(default_branch) {
+  await git_spawn.read_remote(["fetch", "--prune"]);
+  return await delete_each(await read_candidates(default_branch));
+}
+var gone_branch = { parse_records, prune, select_prunable };
+
+// scripts/git/lockfile-sync.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var LOCKFILE_NAME = "pnpm-lock.yaml";
+var RECORD_PATH = path.join("node_modules", ".josh-installed-lock");
+var UP_TO_DATE = { is_installed: true, output: "" };
+function read_text(file_path) {
+  return existsSync(file_path) ? readFileSync(file_path, "utf8") : void 0;
+}
+function digest(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function record(directory, lock_digest) {
+  const record_path = path.join(directory, RECORD_PATH);
+  mkdirSync(path.dirname(record_path), { recursive: true });
+  writeFileSync(record_path, lock_digest);
+}
+async function reinstall_if_stale(directory) {
+  const lock = read_text(path.join(directory, LOCKFILE_NAME));
+  if (lock === void 0) return UP_TO_DATE;
+  const lock_digest = digest(lock);
+  if (read_text(path.join(directory, RECORD_PATH)) === lock_digest) return UP_TO_DATE;
+  const result = await lane_install.install_dependencies(directory);
+  if (result.is_installed) record(directory, lock_digest);
+  return result;
+}
+var lockfile_sync = { reinstall_if_stale };
+
+// scripts/git/main-sync.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var COMMAND_NAME = "main:sync";
+var INSTALL_FAILURE = "node_modules is behind pnpm-lock.yaml and `pnpm install --frozen-lockfile` failed; run `pnpm josh ms` again, or the install here by hand.";
+var LANE_REFUSAL = [
+  `josh ${COMMAND_NAME} cannot run inside a linked work tree.`,
+  "Checking the default branch out here takes it from whichever work tree holds it, and a lane that loses its own branch drops out of `josh lane:list` with its port seat still allocated.",
+  "Run `pnpm josh ms` in the primary checkout instead; a lane is finished with `pnpm josh lane:close <issue-number>`."
+].join("\n");
+function report_prune(result) {
+  if (result.deleted.length > 0) {
+    console.info(`pruned ${String(result.deleted.length)} merged branch(es) whose remote is gone`);
+  }
+  for (const name of result.failed) console.error(`kept ${name}: git branch -d refused it`);
+}
+async function prune_quietly(default_branch) {
+  try {
+    report_prune(await gone_branch.prune(default_branch));
+  } catch (error) {
+    console.error(`branch prune skipped: ${error_text.message_of(error)}`);
+  }
+}
+async function fast_forward_quietly(default_branch) {
+  if (await git_command.branch() === default_branch) return;
+  try {
+    await git_command.fast_forward_local(default_branch);
+  } catch {
+  }
+}
+async function reinstall(root) {
+  const result = await lockfile_sync.reinstall_if_stale(root);
+  if (result.is_installed) return SUCCESS_EXIT_CODE;
+  console.error(`${INSTALL_FAILURE}
+${result.output}`);
+  return FAILURE_EXIT_CODE;
+}
+async function synchronize() {
+  const default_branch = await git_command.get_default_branch();
+  await fast_forward_quietly(default_branch);
+  await git_command.checkout(default_branch);
+  await git_command.pull_fast_forward();
+  await prune_quietly(default_branch);
+  console.info(default_branch);
+  return await reinstall(await git_command.repository_root());
+}
+async function dispatch(argv) {
+  if (argv.length > 0) {
+    console.error(composite_arguments.format_rejection(COMMAND_NAME, []));
+    return USAGE_ERROR_EXIT_CODE;
+  }
+  if (await git_worktree.is_linked()) {
+    console.error(LANE_REFUSAL);
+    return FAILURE_EXIT_CODE;
+  }
+  return await synchronize();
+}
+async function run(argv) {
+  try {
+    return await dispatch(argv);
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+var main_sync = { run };
+
+export {
+  main_sync
+};

package/dist/commands/chunk-HKHGX7TW.js

@@ -0,0 +1,173 @@
+import {
+  repository_labels
+} from "./chunk-5ZXR36N7.js";
+import {
+  github_issue_url
+} from "./chunk-S4X5PJV7.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  MAX_SCANNED,
+  git_gh_issue_list
+} from "./chunk-ZB25RO3U.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  RELEASE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/issue/issue-release.ts
+function is_listing_row(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return Number.isSafeInteger(Reflect.get(value, "number"));
+}
+function open_release_of(json) {
+  const rows = (json_value.parse_array(json) ?? []).filter((row) => is_listing_row(row));
+  return rows.length === 0 ? void 0 : Math.min(...rows.map((row) => row.number));
+}
+function title_of(repo) {
+  return `Release ${repo} (next version)`;
+}
+function body_of(repo) {
+  return [
+    `Tracks the next release of ${repo}.`,
+    "",
+    "Every Issue this one is blocked by changes something a consumer can use only once it is published. Once they have merged, a person runs `pnpm josh release` in the primary checkout.",
+    "",
+    "`pnpm josh release` closes this Issue once that release is published: the next blocker files a new one, so an open release Issue names only unreleased work.",
+    "",
+    "Every Issue this one blocks needs the published version (`pnpm josh issue:release <N> --wait`); closing this Issue hands each of them back to the backlog.",
+    "",
+    "`auto-ok` is never applied to this Issue by a run; a person may apply it.",
+    ""
+  ].join("\n");
+}
+var RELEASE_LABELS = [RELEASE_LABEL];
+var issue_release = { RELEASE_LABELS, open_release_of, title_of, body_of };
+
+// scripts/issue/issue-release-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh issue:release <issue-number> [--wait]";
+var NONE = "none";
+var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote` \u2014 check `gh auth status`.";
+var OPTIONS = { wait: { type: "boolean" } };
+async function find_open(target) {
+  const outcome = await git_gh_issue_list.issue_list({
+    json_fields: "number",
+    limit: MAX_SCANNED,
+    label: RELEASE_LABEL,
+    repo: target
+  });
+  if (outcome.json === void 0) return void 0;
+  return issue_release.open_release_of(outcome.json) ?? NONE;
+}
+async function file_release(target) {
+  repository_labels.ensure_labels(target);
+  const request = git_gh_issue_write.issue_create_request({
+    title: issue_release.title_of(target),
+    body: issue_release.body_of(target),
+    labels: issue_release.RELEASE_LABELS,
+    repo: target
+  });
+  try {
+    const url = await git_gh_exec.exec_gh_api(request);
+    const issue_number = Number(github_issue_url.parse(url)?.issue_number) || void 0;
+    if (issue_number === void 0) console.error(`\u2716 the release number is unreadable: ${url}`);
+    return issue_number;
+  } catch (error) {
+    console.error(`\u2716 the release Issue could not be filed: ${error_text.message_of(error)}`);
+    return void 0;
+  }
+}
+async function release_of(target) {
+  const open = await find_open(target);
+  if (open === void 0) {
+    console.error(`\u2716 the open ${RELEASE_LABEL} Issues of ${target} could not be listed`);
+    return void 0;
+  }
+  if (open !== NONE) return { issue_number: open, is_filed: false };
+  const filed = await file_release(target);
+  return filed === void 0 ? void 0 : { issue_number: filed, is_filed: true };
+}
+function release_label_of(release, target) {
+  const how = release.is_filed ? "filed" : "open";
+  return `${session_cite.issue(release.issue_number, void 0, target)} (${how})`;
+}
+function linked_line(release, request, target) {
+  const release_label = release_label_of(release, target);
+  const issue_label = session_cite.issue(request.issue_number, void 0, target);
+  return request.is_wait ? `release: ${issue_label} waits on ${release_label}` : `release: ${release_label} is blocked by ${issue_label}`;
+}
+function unlinked_line(edge, target) {
+  const blocker = session_cite.issue(edge.blocker, void 0, target);
+  return `\u2716 ${blocker} could not be recorded as a blocker of ${session_cite.issue(edge.blocked, void 0, target)}`;
+}
+function edge_of(release, request) {
+  return request.is_wait ? { blocked: request.issue_number, blocker: release.issue_number } : { blocked: release.issue_number, blocker: request.issue_number };
+}
+async function record(request, target) {
+  const release = await release_of(target);
+  if (release === void 0) return false;
+  const edge = edge_of(release, request);
+  const is_linked = await git_gh_issue_write.issue_add_blocked_by(
+    String(edge.blocked),
+    String(edge.blocker)
+  );
+  if (is_linked) console.info(linked_line(release, request, target));
+  else console.error(unlinked_line(edge, target));
+  return is_linked;
+}
+async function link(issue_number, target) {
+  return await record({ issue_number, is_wait: false }, target);
+}
+function issue_number_of(positionals) {
+  const [issue_number, ...rest] = positionals;
+  const is_single = rest.length === 0 && issue_number !== void 0;
+  return is_single && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number) ? Number(issue_number) : void 0;
+}
+function request_of(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  const issue_number = issue_number_of(parsed?.positionals ?? []);
+  if (parsed === void 0 || issue_number === void 0) return void 0;
+  return { issue_number, is_wait: parsed.values.wait === true };
+}
+async function run(argv) {
+  const request = request_of(argv);
+  if (request === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const current = await git_gh_command.repo_get_name_with_owner();
+  if (current === void 0) {
+    console.error(UNKNOWN_REPO_MESSAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await record(request, current) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var issue_release_cli = { find_open, link, run };
+
+export {
+  NONE,
+  issue_release_cli
+};