@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-KZ5BBBMO.js

@@ -1,271 +0,0 @@
-import {
-  test_related
-} from "./chunk-LT7QSHR4.js";
-import {
-  test_unit_guard
-} from "./chunk-J6WKZRV2.js";
-import {
-  gate_log,
-  verification_tail
-} from "./chunk-FGL6DBZU.js";
-import {
-  moved_paths
-} from "./chunk-RUIBQMOV.js";
-import {
-  review_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  file_map_stamp
-} from "./chunk-CGLLAEKZ.js";
-import {
-  verification_inputs
-} from "./chunk-34KZDKQJ.js";
-import {
-  NOTHING_TO_CHECK_MARKER,
-  NOT_USED_MARKER
-} from "./chunk-IW6NWCSN.js";
-import {
-  josh_verdict
-} from "./chunk-JTU5A4JI.js";
-import {
-  status_icons
-} from "./chunk-65E4OZJ7.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  GATE_COMMAND
-} from "./chunk-TBIX5FRN.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/gate/gate-report.ts
-var { FAIL_ICON, PASS_ICON, WARN_ICON } = status_icons;
-function is_gate_step_failed(result) {
-  return buffered_process.is_process_failed(result);
-}
-function is_skip_notice(result) {
-  return result.output.includes(test_unit_guard.SKIP_MARKER);
-}
-var WARNING_MARKERS = ["warning", "Warning", "\u26A0"];
-function has_warnings(result) {
-  return WARNING_MARKERS.some((marker) => result.output.includes(marker));
-}
-var SAFE_CHAIN_BANNER = "safe-chain is not available";
-var PNPM_SCRIPT_HEADER = "$ ";
-var LINT_FILE_PREFIX = "  - ";
-function checker_lines(result) {
-  return result.output.split("\n").filter((line) => !line.includes(SAFE_CHAIN_BANNER) && !line.startsWith(PNPM_SCRIPT_HEADER));
-}
-function has_checker_warning(result) {
-  if (!gate_labels.WARNING_CHECKER_LABELS.includes(result.label)) return false;
-  return checker_lines(result).filter((line) => result.label !== gate_labels.LINT_LABEL || !line.startsWith(LINT_FILE_PREFIX)).some((line) => WARNING_MARKERS.some((marker) => line.includes(marker)));
-}
-function is_unverified_skip(result) {
-  return checker_lines(result).some(
-    (line) => line.includes(test_unit_guard.SKIP_MARKER) && !line.includes(NOT_USED_MARKER)
-  );
-}
-function has_nothing_to_say(result) {
-  return !is_unverified_skip(result) && !has_checker_warning(result);
-}
-var IDLE_MARKERS = [test_unit_guard.SKIP_MARKER, NOTHING_TO_CHECK_MARKER];
-function is_idle_line(line) {
-  return IDLE_MARKERS.some((marker) => line.includes(marker));
-}
-function is_tool_line(line) {
-  return line.trim() !== "";
-}
-function is_idle(result) {
-  const lines = checker_lines(result).filter((line) => is_tool_line(line));
-  return lines.length > 0 && lines.every((line) => is_idle_line(line));
-}
-function should_print_body(result, is_verbose) {
-  if (is_verbose || is_gate_step_failed(result)) return true;
-  return is_skip_notice(result) || has_warnings(result);
-}
-var SECONDS_DECIMALS = 1;
-function format_seconds(elapsed_ms) {
-  return `${(elapsed_ms / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
-}
-function gate_step_header(result) {
-  const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON;
-  const timing = result.reused_at === void 0 ? format_seconds(result.elapsed_ms) : `reused \u2014 inputs unchanged since it passed at ${result.reused_at}`;
-  return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`;
-}
-function print_gate_step(result, is_verbose) {
-  process.stdout.write(`
-${gate_step_header(result)}
-`);
-  if (should_print_body(result, is_verbose) && result.output) {
-    process.stdout.write(`${result.output}
-`);
-  }
-}
-function format_failure_actions(failed) {
-  if (failed.length === 0) return "";
-  const lines = failed.map(
-    (result) => verification_tail.format_rerun(result.label, `pnpm ${result.command}`)
-  );
-  return `${GATE_COMMAND} \u2014 next:
-${lines.join("\n")}
-`;
-}
-function format_budget_notes(results) {
-  const lines = results.flatMap(
-    (result) => result.budget_note === void 0 ? [] : `  ${WARN_ICON} ${result.label} \u2014 ${result.budget_note}`
-  );
-  return lines.length === 0 ? "" : `${lines.join("\n")}
-`;
-}
-function format_green_verdict(results, total) {
-  const has_skip = results.some((result) => is_skip_notice(result));
-  const skipped = has_skip ? results.filter((result) => is_idle(result)).length : 0;
-  const ran = results.length - skipped;
-  if (ran === 0) return josh_verdict.format_gate_unverified(skipped, total);
-  return josh_verdict.format_gate_passed({ ran, skipped }, total);
-}
-function print_gate_summary(results, report, log_path) {
-  const failed = results.filter((result) => is_gate_step_failed(result));
-  const total = format_seconds(report.elapsed_ms);
-  const verdict = failed.length === 0 ? format_green_verdict(results, total) : josh_verdict.format_gate_failed(failed.map((result) => result.label).join(", "), total);
-  const failures = `${format_budget_notes(results)}${format_failure_actions(failed)}`;
-  process.stdout.write(
-    `
-${verification_tail.format_tail({ failures, log: { path: log_path }, verdict })}`
-  );
-}
-function report_gate_steps(results, report) {
-  for (const result of results) print_gate_step(result, report.is_verbose);
-  const entries = results.map((result) => ({
-    header: gate_step_header(result),
-    output: result.output
-  }));
-  const written_log = gate_log.write_gate_log(entries, report.log_path);
-  print_gate_summary(results, report, written_log);
-  return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label);
-}
-var gate_report = {
-  format_budget_notes,
-  format_failure_actions,
-  has_checker_warning,
-  has_nothing_to_say,
-  is_gate_step_failed,
-  report_gate_steps
-};
-
-// scripts/gate/check-inputs.ts
-import path from "node:path";
-function prettier_ignored(root) {
-  const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name));
-  return async function is_ignored(relative) {
-    try {
-      const prettier = await import("prettier");
-      const info = await prettier.getFileInfo(path.join(root, relative), {
-        ignorePath: ignore_path
-      });
-      return info.ignored;
-    } catch {
-      return false;
-    }
-  };
-}
-async function reads_any(declaration, paths, is_ignored, root) {
-  if (declaration.reads === "recorded") return await test_related.reaches_tests(root, paths);
-  const { is_input } = declaration;
-  if (is_input === void 0) return true;
-  const answers = await Promise.all(
-    paths.map(async (relative) => await is_input(relative, is_ignored))
-  );
-  return answers.includes(true);
-}
-async function touches_inputs(label, paths, is_ignored, root = PROJECT_ROOT) {
-  const declaration = verification_inputs.declaration_of(label);
-  if (declaration === void 0 || verification_inputs.configures(label, paths, root)) return true;
-  return await reads_any(declaration, paths, is_ignored, root);
-}
-var check_inputs = { prettier_ignored, touches_inputs };
-
-// scripts/gate/check-reuse.ts
-var CHECK_PREFIX = "josh-gate-check-";
-function declared_inputs(label) {
-  if (!verification_inputs.is_declared(label)) return void 0;
-  return {
-    fingerprint: () => verification_inputs.fingerprint([label]),
-    touches: async (moved, context) => await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root)
-  };
-}
-function check_stamp(inputs) {
-  return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint);
-}
-function default_records(label) {
-  return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT);
-}
-async function is_stamp_reusable(inputs, stamp, context) {
-  const moved = await moved_paths.moved_since(stamp, context.tree);
-  if (moved === void 0 || !check_stamp(inputs).describes_inputs(stamp)) return false;
-  return !await inputs.touches(moved, context);
-}
-async function reused_at(label, inputs, context) {
-  if (inputs === void 0) return void 0;
-  const stamp = check_stamp(inputs).read(context.records(label));
-  if (stamp === void 0) return void 0;
-  return await is_stamp_reusable(inputs, stamp, context) ? stamp.taken_at : void 0;
-}
-async function read_root() {
-  try {
-    return await git_command.repository_root();
-  } catch {
-    return void 0;
-  }
-}
-async function reusable_checks(labels, tree, records = default_records, inputs_of = declared_inputs) {
-  const root = await read_root();
-  if (root === void 0) return /* @__PURE__ */ new Map();
-  const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) };
-  const answers = await Promise.all(
-    labels.map(
-      async (label) => [label, await reused_at(label, inputs_of(label), context)]
-    )
-  );
-  return new Map(answers.flatMap(([label, at]) => at === void 0 ? [] : [[label, at]]));
-}
-function recordable_inputs(result, inputs_of) {
-  const is_quiet_pass = !gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result);
-  return is_quiet_pass ? inputs_of(result.label) : void 0;
-}
-function write_records(results, tree, records, inputs_of) {
-  for (const result of results) {
-    const inputs = recordable_inputs(result, inputs_of);
-    if (inputs !== void 0) {
-      check_stamp(inputs).write(tree.files, records(result.label), tree.base);
-    }
-  }
-}
-async function record_green_checks(results, tree, records = default_records, inputs_of = declared_inputs) {
-  try {
-    const after = await review_tree.read_changed_tree();
-    if (JSON.stringify(after) !== JSON.stringify(tree.files)) return;
-    write_records(results, { files: after, base: tree.base }, records, inputs_of);
-  } catch {
-  }
-}
-var check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks };
-
-export {
-  gate_report,
-  check_reuse
-};

package/dist/commands/chunk-KZ7HD37E.js

@@ -1,121 +0,0 @@
-import {
-  epic_add,
-  epic_reconcile
-} from "./chunk-HHMMGDMP.js";
-import {
-  epic_bundle_gaps
-} from "./chunk-FMZWRDKH.js";
-import {
-  epic_index
-} from "./chunk-7MJYLUF4.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-blocked-by.ts
-var EPIC_LIMIT = 200;
-var SUCCESS_EXIT_CODE = 0;
-var ALREADY = "already";
-var UNSEEN_EPIC = "the open epics were not read in full, so an epic tracking it may be unseen";
-async function is_blocked(request) {
-  const blockers = await git_gh_issue_read.issue_blocked_by_numbers(request.issue);
-  return blockers.includes(Number(request.prerequisite));
-}
-function is_listed_by(epics, child, epic) {
-  return epic_index.build_tracking_index(epics).get(Number(child))?.includes(epic) === true;
-}
-async function fetch_epics() {
-  const fetched = await epic_index.fetch_epics(EPIC_LIMIT);
-  if (fetched === void 0) throw new Error("the open epics could not be read");
-  return fetched;
-}
-async function tracked_in(issue) {
-  const fetched = await fetch_epics();
-  const epic = epic_index.build_epic_index(fetched.epics).get(Number(issue));
-  if (epic === void 0 && !epic_bundle_gaps.is_membership_established(fetched.cutoff)) {
-    throw new Error(UNSEEN_EPIC);
-  }
-  return { epic, fetched };
-}
-async function tracking_with(issue, children) {
-  const { epic, fetched } = await tracked_in(issue);
-  if (epic === void 0) return void 0;
-  return {
-    epic,
-    lists_children: children.every((child) => is_listed_by(fetched.epics, child, epic))
-  };
-}
-async function tracking_epic(request) {
-  const { epic, fetched } = await tracked_in(request.issue);
-  if (epic === void 0) return void 0;
-  return { epic, is_prerequisite_child: is_listed_by(fetched.epics, request.prerequisite, epic) };
-}
-async function listing_epics(issue) {
-  const fetched = await fetch_epics();
-  if (!epic_bundle_gaps.is_membership_established(fetched.cutoff)) throw new Error(UNSEEN_EPIC);
-  return epic_index.build_tracking_index(fetched.epics).get(Number(issue)) ?? [];
-}
-async function add_to_epic(epic, request) {
-  const code = await epic_add.add_children({
-    epic_number: epic,
-    children: [Number(request.prerequisite)],
-    position: { kind: "before", target: Number(request.issue) }
-  });
-  if (code !== SUCCESS_EXIT_CODE) {
-    throw new Error(`\`epic --add\` into ${session_cite.issue(epic)} failed`);
-  }
-}
-async function record_relation(request) {
-  if (await git_gh_issue_write.issue_add_blocked_by(request.issue, request.prerequisite)) return;
-  throw new Error("the blocked-by relation was not recorded");
-}
-async function refuse_unreconcilable(epic, request) {
-  const link = { blocker: Number(request.prerequisite), blocked: Number(request.issue) };
-  const refusal = await epic_reconcile.refusal_after(epic, link);
-  if (refusal === void 0) return;
-  throw new Error(
-    `\`pnpm josh epic --reconcile ${String(epic)}\` would refuse the relation, so none was recorded: ${refusal}`
-  );
-}
-async function reconcile_epic(epic) {
-  if (await epic_reconcile.reconcile_epic(epic) === SUCCESS_EXIT_CODE) return;
-  throw new Error(
-    `the relation was recorded, but \`pnpm josh epic --reconcile ${String(epic)}\` failed to declare it`
-  );
-}
-async function record_in_epic(tracking, request) {
-  if (tracking.is_prerequisite_child) {
-    await refuse_unreconcilable(tracking.epic, request);
-    await record_relation(request);
-    await reconcile_epic(tracking.epic);
-  } else {
-    await add_to_epic(tracking.epic, request);
-    if (!await is_blocked(request)) await record_relation(request);
-  }
-  return `recorded in epic ${session_cite.issue(tracking.epic)}`;
-}
-async function settle_recorded(request) {
-  const tracking = await tracking_epic(request);
-  if (tracking?.is_prerequisite_child === true) await reconcile_epic(tracking.epic);
-  return ALREADY;
-}
-async function record(request) {
-  if (await is_blocked(request)) return await settle_recorded(request);
-  const tracking = await tracking_epic(request);
-  if (tracking !== void 0 && (request.is_relation_only !== true || tracking.is_prerequisite_child)) {
-    return await record_in_epic(tracking, request);
-  }
-  await record_relation(request);
-  return "recorded";
-}
-var epic_blocked_by = { record, listing_epics, tracking_with };
-
-export {
-  epic_blocked_by
-};

package/dist/commands/chunk-KZSM5M5P.js

@@ -1,89 +0,0 @@
-import {
-  git_closes_keyword
-} from "./chunk-J3TKZLHA.js";
-import {
-  git_gh_repo
-} from "./chunk-GJYMI2CM.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec,
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-
-// scripts/issue/issue-closing-pr.ts
-import { z } from "zod";
-var LINE_SEPARATOR = "\n";
-var TIMELINE_FILTER = [
-  ".[]",
-  '| if .event == "cross-referenced" and .source.issue.pull_request != null',
-  'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // ""), state: (if .source.issue.pull_request.merged_at != null then "merged" else .source.issue.state end)}',
-  'elif .event == "reopened" then {reopened: true}',
-  "else empty end"
-].join(" ");
-var reference_schema = z.object({
-  url: z.string(),
-  repo: z.string(),
-  body: z.string(),
-  state: z.enum(["open", "closed", "merged"]).default("merged")
-});
-var reopen_schema = z.object({ reopened: z.literal(true) });
-var row_schema = z.union([reference_schema, reopen_schema]);
-function is_reference(row) {
-  return "url" in row;
-}
-function parse_row(line) {
-  const row = parse_json_object_or_undefined(line, row_schema);
-  if (row === void 0) throw new Error("the issue timeline contains an unreadable row");
-  return row;
-}
-function parse_references(raw) {
-  const rows = raw.split(LINE_SEPARATOR).filter((line) => line.trim() !== "").map((line) => parse_row(line));
-  const last_reopen = rows.findLastIndex((row) => !is_reference(row));
-  return rows.slice(last_reopen + 1).filter((row) => is_reference(row));
-}
-function pick_closing_pr(references, issue, repo) {
-  return references.find(
-    (reference) => reference.repo === repo && reference.state === "merged" && git_closes_keyword.parse_closes_issue_number(reference.body) === issue
-  )?.url;
-}
-async function read_closing_result(issue) {
-  try {
-    const [raw, repo] = await Promise.all([
-      git_gh_exec.exec_gh_api({
-        path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
-        should_paginate: true,
-        jq_filter: TIMELINE_FILTER
-      }),
-      git_gh_repo.repo_get_canonical_name_with_owner()
-    ]);
-    if (repo === void 0) return { kind: "unreadable" };
-    return { kind: "read", url: pick_closing_pr(parse_references(raw), issue, repo) };
-  } catch {
-    return { kind: "unreadable" };
-  }
-}
-async function read_closing_pr(issue) {
-  const result = await read_closing_result(issue);
-  return result.kind === "read" ? result.url : void 0;
-}
-async function read_closing_number_result(issue) {
-  const result = await read_closing_result(String(issue));
-  if (result.kind === "unreadable") return result;
-  const number = result.url === void 0 ? void 0 : Number(result.url.slice(result.url.lastIndexOf("/") + 1));
-  return { kind: "read", number };
-}
-async function read_closing_number(issue) {
-  const result = await read_closing_number_result(issue);
-  return result.kind === "read" ? result.number : void 0;
-}
-var issue_closing_pr = {
-  read_closing_number,
-  read_closing_number_result,
-  read_closing_pr
-};
-
-export {
-  issue_closing_pr
-};

package/dist/commands/chunk-KZZWPUJW.js

@@ -1,25 +0,0 @@
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-
-// scripts/run/hold/run-hold-block.ts
-function held_block(hold, issue) {
-  return run_hold.is_reentry(hold, issue) ? void 0 : run_hold.held_message(hold);
-}
-function is_own_unstopped(hold, issue) {
-  return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold);
-}
-async function stale_block(hold, issue) {
-  if (is_own_unstopped(hold, issue)) return void 0;
-  return await run_hold.is_tree_dirty() ? run_hold.uncommitted_message(hold) : void 0;
-}
-async function blocking_message(read, issue) {
-  if (read.kind === "held") return held_block(read.hold, issue);
-  if (read.kind === "unreadable") return run_hold.unreadable_message();
-  return read.kind === "stale" ? await stale_block(read.hold, issue) : void 0;
-}
-var run_hold_block = { blocking_message };
-
-export {
-  run_hold_block
-};