@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-VA4M733Q.js

@@ -0,0 +1,127 @@
+import {
+  git_prompt
+} from "./chunk-YSL43R4Y.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  SEPARATOR_LINE
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/git/git-issue.ts
+var ISSUE_NUMBER_PATTERN = /#(\d+)$/u;
+function extract_issue_number(input) {
+  const match = ISSUE_NUMBER_PATTERN.exec(input);
+  if (match === null) {
+    throw new Error('Invalid format: Issue number not found (e.g., "title #52")');
+  }
+  return match[1] ?? "";
+}
+function extract_issue_title(input) {
+  const title = input.replace(/#\d+$/u, "").trim();
+  if (title.length === 0) {
+    throw new Error("Invalid format: Issue title is required");
+  }
+  return title;
+}
+function normalize_title_for_branch(title) {
+  const replaced = title.toLowerCase().normalize("NFKD").replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/(^-)|(-$)/gu, "");
+  return replaced.length === 0 ? "update" : replaced;
+}
+function create_branch_name(issue_number, title) {
+  return `${issue_number}-${normalize_title_for_branch(title)}`;
+}
+function parse_issue_input(input) {
+  const trimmed_input = input.trim();
+  const issue_number = extract_issue_number(trimmed_input);
+  const title = extract_issue_title(trimmed_input);
+  const branch_name = create_branch_name(issue_number, title);
+  const commit_message = `${title} ${issue_cite.plain_for("github", issue_number)}`;
+  return {
+    title,
+    number: issue_number,
+    branch_name,
+    commit_message
+  };
+}
+var BRANCH_NUMBER_PATTERN = /^(\d+)-(.+)$/u;
+function is_lane_branch(branch_name, issue_number) {
+  return branch_name === lane_paths.lane_branch(issue_number);
+}
+var EXAMPLE_ISSUE_NUMBER = "42";
+function argument_hint(issue_number) {
+  return `Provide an issue argument like "title ${issue_cite.plain_for("github", issue_number)}".`;
+}
+async function lane_issue_title(branch_name, issue_number) {
+  const title = await git_gh_issue_read.issue_get_title(issue_number);
+  if (title === void 0) {
+    throw new Error(
+      `Cannot read the title of issue ${session_cite.issue(issue_number)} for lane branch "${branch_name}". ${argument_hint(issue_number)}`
+    );
+  }
+  return title;
+}
+function branch_derivation_error(branch_name) {
+  return `Cannot derive issue info from branch "${branch_name}" in non-interactive mode. ${argument_hint(EXAMPLE_ISSUE_NUMBER)}`;
+}
+function branch_number(branch_name) {
+  return BRANCH_NUMBER_PATTERN.exec(branch_name)?.[1];
+}
+async function derive_issue_input_from_branch(branch_name) {
+  const match = BRANCH_NUMBER_PATTERN.exec(branch_name);
+  if (match === null) throw new Error(branch_derivation_error(branch_name));
+  const [, number = "", slug = ""] = match;
+  const title = is_lane_branch(branch_name, number) ? await lane_issue_title(branch_name, number) : slug.replaceAll("-", " ").trim();
+  return `${title} ${issue_cite.plain_for("github", number)}`;
+}
+async function derive_from_branch(branch_name) {
+  const parsed = parse_issue_input(await derive_issue_input_from_branch(branch_name));
+  return { ...parsed, branch_name };
+}
+function display_issue_info(issue_info) {
+  console.info("");
+  console.info("\u{1F4CB} Issue Information");
+  console.info(SEPARATOR_LINE);
+  console.info(`  Issue Title: ${issue_info.title}`);
+  console.info(`  Issue Number: ${issue_info.number}`);
+  console.info(`  Branch Name: ${issue_info.branch_name}`);
+  console.info(`  Commit Message: ${issue_info.commit_message}`);
+  console.info(SEPARATOR_LINE);
+}
+async function get_and_display(cli_input) {
+  const input = cli_input ?? await git_prompt.get_issue_info();
+  const issue_info = parse_issue_input(input);
+  display_issue_info(issue_info);
+  return issue_info;
+}
+async function resolve_and_display(input) {
+  if (input.cli_input !== void 0) return await get_and_display(input.cli_input);
+  if (input.is_non_interactive) {
+    const issue_info = await derive_from_branch(input.current_branch);
+    display_issue_info(issue_info);
+    return issue_info;
+  }
+  return await get_and_display();
+}
+var git_issue = {
+  get_and_display,
+  resolve_and_display,
+  derive_from_branch,
+  // The pure halves of the two resolutions above, read by `git-preflight.ts` before anything changes.
+  parse: parse_issue_input,
+  branch_number,
+  branch_derivation_error
+};
+
+export {
+  git_issue
+};

package/dist/commands/chunk-VBZ47BVH.js

@@ -0,0 +1,64 @@
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/repo/repo-setting.ts
+var GH_TIMEOUT_MS = 5e3;
+var REPO_PLACEHOLDER = "<owner>/<repo>";
+var UNKNOWN_REPOSITORY = "unknown repository";
+var FAILED_EXIT_CODE = 1;
+function query_repo_api(api_path) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: api_path,
+    cwd: PROJECT_ROOT,
+    timeout_ms: GH_TIMEOUT_MS
+  });
+  return stdout === void 0 ? { exit_code: FAILED_EXIT_CODE, stdout: "" } : { exit_code: 0, stdout };
+}
+function parse_payload(exit_code, stdout) {
+  if (exit_code !== 0) return void 0;
+  const parsed = json_value.parse_or_undefined(stdout);
+  return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+}
+function read_field(payload, field) {
+  return payload === void 0 ? void 0 : Reflect.get(payload, field);
+}
+function classify_boolean_setting(payload, field) {
+  const value = read_field(payload, field);
+  if (typeof value !== "boolean") return "unreadable";
+  return value ? "enabled" : "disabled";
+}
+function command_target(repo) {
+  return repo ?? REPO_PLACEHOLDER;
+}
+function report_target(repo) {
+  return repo ?? UNKNOWN_REPOSITORY;
+}
+function print_section(lines) {
+  console.info("");
+  for (const line of lines) {
+    console.info(line);
+  }
+}
+var repo_setting = {
+  GH_TIMEOUT_MS,
+  REPO_PLACEHOLDER,
+  UNKNOWN_REPOSITORY,
+  query_repo_api,
+  parse_payload,
+  read_field,
+  classify_boolean_setting,
+  command_target,
+  report_target,
+  print_section
+};
+
+export {
+  repo_setting
+};

package/dist/commands/chunk-VD4ELMDA.js

@@ -0,0 +1,158 @@
+import {
+  review_reviewed_tree
+} from "./chunk-JKPYLZ6T.js";
+import {
+  review_record
+} from "./chunk-NASUAXRJ.js";
+import {
+  issue_watch_gate
+} from "./chunk-GLXOLYZE.js";
+import {
+  run_preflight
+} from "./chunk-ZNFVJETO.js";
+import {
+  git_worktree
+} from "./chunk-2AH73ZTW.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/review/review-round-reuse.ts
+async function is_stale_here() {
+  try {
+    return await issue_watch_gate.review_refusal_here() !== void 0;
+  } catch (error) {
+    error_text.trace_swallowed("review_round_reuse.is_stale_here", error);
+    return false;
+  }
+}
+var REUSE = { AGAIN: "again", DELTA: "delta", HELD: "held" };
+var { MOVEMENT } = review_reviewed_tree;
+var STALE_CAUSE = "the issue changed after the recorded round's brief";
+var UNRECORDED_CAUSE = "no review round is recorded for this issue";
+function reused_with(kind, note) {
+  return note === void 0 ? { reuse: kind } : { reuse: kind, note };
+}
+async function recorded_answer(issue) {
+  const { movement, cause, note } = await review_reviewed_tree.standing_here();
+  if (movement === MOVEMENT.HELD) return reused_with(REUSE.HELD, note);
+  const is_delta = movement === MOVEMENT.DELTA || review_reviewed_tree.is_stopped_on(issue);
+  return is_delta ? reused_with(REUSE.DELTA, note) : { reuse: REUSE.AGAIN, cause };
+}
+async function answer(issue, is_stale) {
+  if (is_stale) return { reuse: REUSE.AGAIN, cause: STALE_CAUSE };
+  const recorded = await review_record.check(issue);
+  if (recorded.status !== "ok") return { reuse: REUSE.AGAIN, cause: UNRECORDED_CAUSE };
+  return await recorded_answer(issue);
+}
+async function reuse(issue, is_stale) {
+  const reused = await answer(issue, is_stale);
+  return reused.reuse;
+}
+async function is_reusable(issue, is_stale) {
+  return await reuse(issue, is_stale) !== REUSE.AGAIN;
+}
+async function answer_here(issue) {
+  return await answer(issue, await is_stale_here());
+}
+async function reuse_here(issue) {
+  const reused = await answer_here(issue);
+  return reused.reuse;
+}
+async function is_reusable_here(issue) {
+  return await reuse_here(issue) !== REUSE.AGAIN;
+}
+var review_round_reuse = {
+  REUSE,
+  answer,
+  answer_here,
+  is_reusable,
+  is_reusable_here,
+  is_stale_here,
+  reuse_here
+};
+
+// scripts/run/ship/run-ship-probe.ts
+var REMOTE_SHA_INDEX = 0;
+var REMOTE_FIELD_SEPARATOR = /\s/u;
+var HEAD_REFERENCE = "HEAD";
+async function or_false(is_true) {
+  try {
+    return await is_true();
+  } catch (error) {
+    error_text.trace_swallowed("run_ship_probe.or_false", error);
+    return false;
+  }
+}
+async function read_committed(is_dirty) {
+  if (is_dirty) return false;
+  const base = await git_command.default_branch_reference();
+  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) > 0;
+}
+async function read_pushed(branch_name) {
+  const [remote, head] = await Promise.all([
+    git_worktree.ls_remote_branch(branch_name),
+    git_command.head_commit()
+  ]);
+  return remote.split(REMOTE_FIELD_SEPARATOR)[REMOTE_SHA_INDEX] === head;
+}
+async function read_merged(branch_name) {
+  if (await run_preflight.read_pr_state(branch_name) !== run_preflight.MERGED_PR) return false;
+  const base = await git_command.default_branch_reference();
+  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) === 0;
+}
+async function read_review_stale() {
+  return await review_round_reuse.is_stale_here();
+}
+var NOTHING_DONE = { is_committed: false, is_pushed: false, is_merged: false };
+async function read_branch_state(branch_name) {
+  const is_dirty = await run_hold.is_tree_dirty();
+  const [is_committed, is_pushed, is_merged, is_review_stale] = await Promise.all([
+    or_false(async () => await read_committed(is_dirty)),
+    or_false(async () => await read_pushed(branch_name)),
+    or_false(async () => await read_merged(branch_name)),
+    read_review_stale()
+  ]);
+  return { is_committed, is_pushed, is_merged, is_review_stale, is_dirty };
+}
+async function is_pushed_clean() {
+  if (await run_hold.is_tree_dirty()) return false;
+  return await or_false(async () => await read_pushed(await git_command.branch()));
+}
+async function read_state() {
+  try {
+    return await read_branch_state(await git_command.branch());
+  } catch {
+    return NOTHING_DONE;
+  }
+}
+async function record_target(issue) {
+  const repository = await git_common_directory.read_repository();
+  return repository === void 0 ? void 0 : run_ship_stage.record_path(repository, issue);
+}
+var run_ship_probe = {
+  is_pushed_clean,
+  read_review_stale,
+  read_state,
+  record_target,
+  // The leaf's read, kept on the ship's surface for its own callers; a module outside the ship's
+  // stages imports `git_common_directory` so it does not reach the review modules this one does.
+  repository_directory: git_common_directory.read_repository
+};
+
+export {
+  review_round_reuse,
+  run_ship_probe
+};