@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-C3Y42PHX.js

@@ -0,0 +1,229 @@
+import {
+  issue_watch_diff
+} from "./chunk-44UIURBQ.js";
+import {
+  git_gh_issue_memo
+} from "./chunk-V6WWW6HX.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  gh_failure,
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/gh/git-gh-issue-write.ts
+var PATCH_METHOD = "PATCH";
+var DELETE_METHOD = "DELETE";
+var HTML_URL_FILTER = ".html_url";
+var ID_FILTER = ".id";
+var LABEL_NAMES_FILTER = ".[].name";
+var LABELS_SEGMENT = "/labels";
+var COMMENTS_SEGMENT = "/comments";
+var CLOSED_STATE = "closed";
+var COLOR_HASH = "#";
+var UNPROCESSABLE_STATUS = 422;
+var ALREADY_EXISTS_CODE = "already_exists";
+async function did_write_succeed(write) {
+  try {
+    await write();
+    return true;
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_issue_write.did_write_succeed", error);
+    return false;
+  }
+}
+async function write_api(request) {
+  try {
+    return await git_gh_exec.exec_gh_api(request);
+  } finally {
+    git_gh_issue_memo.forget();
+  }
+}
+async function issue_patch(issue_number, fields, repo) {
+  return await write_api({
+    path: git_gh_api_path.issue_api_path(issue_number, repo),
+    method: PATCH_METHOD,
+    body: JSON.stringify(fields),
+    jq_filter: HTML_URL_FILTER
+  });
+}
+async function issue_edit_body(issue_number, body, repo) {
+  return await issue_patch(issue_number, { body }, repo);
+}
+async function issue_edit_title(issue_number, title, repo) {
+  return await issue_patch(issue_number, { title }, repo);
+}
+async function issue_comment(issue_number, body, repo) {
+  return await write_api({
+    path: `${git_gh_api_path.issue_api_path(issue_number, repo)}${COMMENTS_SEGMENT}`,
+    body: JSON.stringify({ body: `${body}
+
+${issue_watch_diff.RUN_MARKER}` }),
+    jq_filter: HTML_URL_FILTER
+  });
+}
+async function issue_try_comment(issue_number, body, repo) {
+  return await did_write_succeed(async () => await issue_comment(issue_number, body, repo));
+}
+async function close_with(issue_number, comment, state) {
+  return await did_write_succeed(async () => {
+    if (comment !== void 0) await issue_comment(issue_number, comment);
+    await write_api({
+      path: git_gh_api_path.issue_api_path(issue_number),
+      method: PATCH_METHOD,
+      body: JSON.stringify(state)
+    });
+  });
+}
+async function issue_close(issue_number, comment, reason) {
+  const state = reason === void 0 ? {} : { state_reason: reason };
+  return await close_with(issue_number, comment, { state: CLOSED_STATE, ...state });
+}
+function to_label_color(color) {
+  return color.startsWith(COLOR_HASH) ? color.slice(COLOR_HASH.length) : color;
+}
+function is_label_already_exists(error) {
+  if (gh_failure.failure_of(error)?.status !== UNPROCESSABLE_STATUS) return false;
+  return error_text.message_of(error).includes(ALREADY_EXISTS_CODE);
+}
+async function label_ensure(input) {
+  try {
+    await git_gh_exec.exec_gh_api({
+      path: `${git_gh_api_path.repo_api_path()}${LABELS_SEGMENT}`,
+      body: JSON.stringify({
+        name: input.name,
+        color: to_label_color(input.color),
+        description: input.description
+      })
+    });
+  } catch (error) {
+    if (is_label_already_exists(error)) return;
+    const [gist = ""] = error_text.message_of(error).split("\n", 1);
+    console.warn(`\u26A0 could not create the \`${input.name}\` label \u2014 ${gist}`);
+  }
+}
+function issue_create_request(input) {
+  const { labels } = input;
+  return {
+    path: git_gh_api_path.issues_api_path(input.repo),
+    body: JSON.stringify({
+      title: input.title,
+      ...labels !== void 0 && { labels },
+      body: input.body
+    }),
+    jq_filter: HTML_URL_FILTER,
+    // A 502 can follow an issue GitHub already opened, and a retry would open a second one.
+    should_retry: false
+  };
+}
+async function issue_create_with_label(input) {
+  return await git_gh_exec.exec_gh_api(
+    issue_create_request({ title: input.title, body: input.body, labels: [input.label] })
+  );
+}
+async function read_label_names(issue_number, repo) {
+  try {
+    const raw = await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.issue_labels_api_path(issue_number, repo),
+      should_paginate: true,
+      jq_filter: LABEL_NAMES_FILTER
+    });
+    return raw.split("\n").map((name) => name.trim());
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_issue_write.read_label_names", error);
+    return void 0;
+  }
+}
+async function issue_apply_label(issue_number, label, repo) {
+  const labels_path = git_gh_api_path.issue_labels_api_path(issue_number, repo);
+  try {
+    await write_api({ path: labels_path, body: JSON.stringify({ labels: [label] }) });
+    return { is_applied: true };
+  } catch (error) {
+    const names = await read_label_names(issue_number, repo);
+    if (names?.includes(label) === true) return { is_applied: true };
+    error_text.trace_swallowed("git_gh_issue_write.issue_apply_label", error);
+    const [gist = ""] = error_text.message_of(error).split("\n", 1);
+    return { is_applied: false, reason: gist };
+  }
+}
+async function issue_add_label(issue_number, label, repo) {
+  const write = await issue_apply_label(issue_number, label, repo);
+  return write.is_applied;
+}
+async function issue_remove_label(issue_number, label) {
+  const labels_path = git_gh_api_path.issue_labels_api_path(issue_number);
+  await write_api({
+    path: `${labels_path}/${encodeURIComponent(label)}`,
+    method: DELETE_METHOD
+  });
+}
+async function issue_clear_label(issue_number, label) {
+  try {
+    await issue_remove_label(issue_number, label);
+    return true;
+  } catch (error) {
+    const names = await read_label_names(issue_number);
+    if (names?.includes(label) === false) return true;
+    error_text.trace_swallowed("git_gh_issue_write.issue_clear_label", error);
+    return false;
+  }
+}
+async function read_issue_id(issue_number) {
+  const raw = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.issue_api_path(issue_number),
+    jq_filter: ID_FILTER
+  });
+  const issue_id = Number(raw.trim());
+  if (!Number.isSafeInteger(issue_id) || issue_id <= 0) {
+    throw new Error(`gh api answered no database id for issue ${session_cite.issue(issue_number)}`);
+  }
+  return issue_id;
+}
+async function issue_add_blocked_by(issue_number, blocker) {
+  return await did_write_succeed(async () => {
+    const issue_id = await read_issue_id(blocker);
+    await write_api({
+      path: git_gh_api_path.blocked_by_api_path(issue_number),
+      body: JSON.stringify({ issue_id })
+    });
+  });
+}
+async function issue_remove_blocked_by(issue_number, blocker) {
+  return await did_write_succeed(async () => {
+    const issue_id = await read_issue_id(blocker);
+    const relations_path = git_gh_api_path.blocked_by_api_path(issue_number);
+    await write_api({
+      path: `${relations_path}/${String(issue_id)}`,
+      method: DELETE_METHOD
+    });
+  });
+}
+var git_gh_issue_write = {
+  issue_edit_body,
+  issue_edit_title,
+  issue_comment,
+  issue_try_comment,
+  issue_close,
+  label_ensure,
+  issue_create_request,
+  issue_create_with_label,
+  read_label_names,
+  issue_apply_label,
+  issue_add_label,
+  issue_remove_label,
+  issue_clear_label,
+  issue_add_blocked_by,
+  issue_remove_blocked_by
+};
+
+export {
+  git_gh_issue_write
+};

package/dist/commands/chunk-C7CDGSMW.js

@@ -0,0 +1,112 @@
+import {
+  animation_helpers,
+  create_git_operation_config
+} from "./chunk-GO3GH7FG.js";
+import {
+  BranchMismatchError
+} from "./chunk-XMZJB7JP.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/git/git-branch.ts
+async function current() {
+  const config = {
+    error_message: "Failed to get current branch"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Getting current branch...",
+    git_command.branch,
+    config
+  );
+}
+async function create(branch_name) {
+  const config = create_git_operation_config("Failed to create branch");
+  await animation_helpers.execute_with_animation(
+    `Creating branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout_b(branch_name);
+      return `Branch created: ${branch_name}`;
+    },
+    config
+  );
+}
+async function switch_to(branch_name) {
+  const config = create_git_operation_config("Failed to switch branch");
+  await animation_helpers.execute_with_animation(
+    `Switching to branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout(branch_name);
+      return `Switched to branch: ${branch_name}`;
+    },
+    config
+  );
+}
+async function exists(branch_name) {
+  const config = {
+    error_message: "Failed to check branch existence",
+    result_formatter: (is_exists) => is_exists ? "Exists" : "Not found"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Checking if branch exists...",
+    async () => {
+      return await git_command.branch_exists(branch_name);
+    },
+    config
+  );
+}
+async function pull_latest() {
+  const config = create_git_operation_config("Failed to pull latest from remote");
+  await animation_helpers.execute_with_animation(
+    "Pulling latest from remote...",
+    async () => {
+      await git_command.pull_fast_forward();
+      return "Pulled latest from remote";
+    },
+    config
+  );
+}
+var ISSUE_PREFIX_PATTERN = /^(\d+)-/u;
+function has_same_issue_prefix(branch_a, branch_b) {
+  const prefix_a = ISSUE_PREFIX_PATTERN.exec(branch_a)?.[0];
+  const prefix_b = ISSUE_PREFIX_PATTERN.exec(branch_b)?.[0];
+  return prefix_a !== void 0 && prefix_a === prefix_b;
+}
+function issue_from_branch(branch) {
+  const digits = ISSUE_PREFIX_PATTERN.exec(branch)?.[1];
+  return digits === void 0 ? void 0 : Number(digits);
+}
+function is_mismatch(current_branch, target_branch_name, default_branch) {
+  if (current_branch === default_branch || current_branch === target_branch_name) return false;
+  return !has_same_issue_prefix(current_branch, target_branch_name);
+}
+async function handle_default_branch(target_branch_name) {
+  await pull_latest();
+  const is_branch_exists = await exists(target_branch_name);
+  await (is_branch_exists ? switch_to : create)(target_branch_name);
+}
+async function check_and_create_branch(current_branch, target_branch_name) {
+  const default_branch = await git_command.get_default_branch();
+  if (current_branch === default_branch) {
+    await handle_default_branch(target_branch_name);
+    return target_branch_name;
+  }
+  if (is_mismatch(current_branch, target_branch_name, default_branch)) {
+    throw new BranchMismatchError({ current_branch, target_branch_name });
+  }
+  return current_branch;
+}
+var git_branch = {
+  current,
+  check_and_create_branch,
+  is_mismatch,
+  // Exported so a lane's branch name can be checked against the real matcher rather than against a
+  // second copy of the pattern. A copy is what let `lane/<N>` ship: nothing
+  // asserted that the name `lane:open` writes is one this function accepts.
+  has_same_issue_prefix,
+  issue_from_branch
+};
+
+export {
+  git_branch
+};

package/dist/commands/chunk-C7JEMYPV.js

@@ -0,0 +1,102 @@
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_subject_schema
+} from "./chunk-34DND4BA.js";
+import {
+  EPIC_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/epic/epic-validate.ts
+function parse_epic_subject(raw_json) {
+  if (raw_json === void 0) return void 0;
+  const parsed = parse_json_object_or_undefined(raw_json, epic_subject_schema);
+  if (parsed === void 0) return void 0;
+  return {
+    number: parsed.number,
+    state: parsed.state,
+    labels: (parsed.labels ?? []).map((label) => label.name),
+    body: parsed.body
+  };
+}
+function check_label(subject) {
+  const is_passing = has_label_name(subject.labels, EPIC_LABEL);
+  return {
+    name: "epic label",
+    is_passing,
+    detail: is_passing ? `the \`${EPIC_LABEL}\` label is applied` : `add the \`${EPIC_LABEL}\` label \u2014 the auto-close only looks at labelled issues`
+  };
+}
+function format_children(children) {
+  return children.map((child) => session_cite.issue(child)).join(", ");
+}
+function check_task_list(subject) {
+  const children = epic_parse.parse_task_list_issue_numbers(subject.body);
+  const is_passing = children.length > 0;
+  return {
+    name: "child task list",
+    is_passing,
+    detail: is_passing ? `${String(children.length)} child issue(s) tracked: ${format_children(children)}` : "no `- [ ] #N` rows found \u2014 a bare `#N` link is not tracked and never auto-closes"
+  };
+}
+function describe_dependencies(state) {
+  if (state.has_chain && state.has_none_literal) {
+    return "a chain (`#N -> #M`) and the `None \u2014 ...` literal are both declared; they contradict each other";
+  }
+  if (state.has_chain) return "an ordered chain (`#N -> #M`) is declared";
+  if (state.has_none_literal) return "declared as an unordered batch";
+  return "neither a line that is only `#N -> #M` nor the `None \u2014 ...` literal found; an arrow sharing its line with anything else is prose, and prose order is not machine-readable";
+}
+function check_dependencies(subject) {
+  const state = epic_parse.read_declaration(subject.body);
+  return {
+    name: "dependencies section",
+    is_passing: epic_parse.is_declaration_readable(state),
+    detail: describe_dependencies(state)
+  };
+}
+function check_external_children(subject) {
+  const has_external = epic_parse.has_external_task_list_entry(subject.body);
+  return {
+    name: "auto-close eligibility",
+    is_passing: !has_external,
+    detail: has_external ? "tracks a child in another repository \u2014 this epic will not auto-close; close it manually" : "every tracked child is in this repository"
+  };
+}
+function validate_epic(subject) {
+  return [
+    check_label(subject),
+    check_task_list(subject),
+    check_dependencies(subject),
+    check_external_children(subject)
+  ];
+}
+function is_epic_valid(results) {
+  return results.every((result) => result.is_passing);
+}
+function format_check_line(result) {
+  return `${result.is_passing ? "\u2714" : "\u2716"} ${result.name} \u2014 ${result.detail}`;
+}
+function format_check_report(epic_number, results) {
+  const lines = results.map((result) => format_check_line(result));
+  const summary = is_epic_valid(results) ? `\u2705 Epic ${session_cite.issue(epic_number)} satisfies every requirement.` : `\u274C Epic ${session_cite.issue(epic_number)} does not satisfy every requirement.`;
+  return [...lines, "", summary].join("\n");
+}
+var epic_validate = {
+  parse_epic_subject,
+  validate_epic,
+  is_epic_valid,
+  format_check_report
+};
+
+export {
+  epic_validate
+};