@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-ULVVGGTY.js

@@ -1,64 +0,0 @@
-import {
-  timed_fetch
-} from "./chunk-5HVYOIIK.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/sonar/sonar-project.ts
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-var SONAR_HOST = "https://sonarcloud.io";
-var PROPERTIES_FILE = "sonar-project.properties";
-var PROJECT_KEY_PREFIX = "sonar.projectKey=";
-var TOKEN_VARIABLE = "SONAR_TOKEN";
-var AUTHORIZATION_HEADER = "Authorization";
-function read_project_key(root) {
-  const file = path.join(root, PROPERTIES_FILE);
-  if (!existsSync(file)) return void 0;
-  const line = readFileSync(file, "utf8").split("\n").find((entry) => entry.startsWith(PROJECT_KEY_PREFIX));
-  return line?.slice(PROJECT_KEY_PREFIX.length).trim();
-}
-function api_url(api_path, query) {
-  return `${SONAR_HOST}${api_path}?${new URLSearchParams(query).toString()}`;
-}
-function request_init() {
-  const token = process.env[TOKEN_VARIABLE] ?? "";
-  return token === "" ? {} : { headers: [[AUTHORIZATION_HEADER, `Bearer ${token}`]] };
-}
-async function fetch_json(url, schema) {
-  try {
-    const response = await timed_fetch(url, request_init());
-    if (!response.ok) return { error: `HTTP ${String(response.status)}` };
-    return { data: schema.parse(await response.json()) };
-  } catch (error) {
-    return { error: error_text.message_of(error) };
-  }
-}
-async function resolve_target(argv, usage) {
-  const [pull_request] = argv;
-  if (pull_request === void 0 || pull_request.startsWith("-")) {
-    console.error(usage);
-    return void 0;
-  }
-  const project_key = read_project_key(await git_command.repository_root());
-  if (project_key === void 0) {
-    console.error(`no ${PROJECT_KEY_PREFIX} found in ${PROPERTIES_FILE}`);
-    return void 0;
-  }
-  return { project_key, pull_request };
-}
-var sonar_project = {
-  api_url,
-  fetch_json,
-  read_project_key,
-  request_init,
-  resolve_target
-};
-
-export {
-  sonar_project
-};

package/dist/commands/chunk-UNMSZGSG.js

@@ -1,269 +0,0 @@
-import {
-  lane_plan_wait,
-  lane_plan_wait_until
-} from "./chunk-SJ2ZN575.js";
-import {
-  lane_plan_probe,
-  lane_plan_size
-} from "./chunk-2QM72JCJ.js";
-import {
-  trusted_measure
-} from "./chunk-M6JDU5EK.js";
-import {
-  run_hold_cli
-} from "./chunk-4ZQM4I7R.js";
-import {
-  backlog_plan_comment
-} from "./chunk-AVVMDVGO.js";
-import {
-  auto_ok_cli
-} from "./chunk-FMZWRDKH.js";
-import {
-  measure_declaration
-} from "./chunk-34JJYCIY.js";
-import {
-  lane_plan_wait_event
-} from "./chunk-6DDK5XWK.js";
-import {
-  lane_yield
-} from "./chunk-EGIHAEMT.js";
-import {
-  backlog_overlap,
-  lane_plan
-} from "./chunk-B7ZNIEDV.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  line_budget
-} from "./chunk-KKIMVXAP.js";
-
-// scripts/lane/lane-plan-check.ts
-import path from "node:path";
-
-// scripts/lane/lane-plan-premise.ts
-function listed_premises(issue, issues) {
-  const listed = issues?.find((candidate) => candidate.number === issue);
-  return listed === void 0 ? void 0 : measure_declaration.premises(listed.body ?? "").length;
-}
-function measured(declaration, run) {
-  if (run.kind === "failed") return { holds: false, value: `failed (${run.message})` };
-  const verdict = measure_declaration.judge(declaration, run.output);
-  const value = "value" in verdict ? String(verdict.value) : verdict.kind;
-  return { holds: verdict.kind === "pass", value };
-}
-function checked(declaration, source) {
-  const result = measured(declaration, trusted_measure.run_command(declaration.command, source));
-  const line = `${measure_declaration.format(declaration)} measured ${result.value}`;
-  console.error(`premise: ${line}`);
-  return result.holds ? void 0 : line;
-}
-async function failed_premises(issue, issues) {
-  const listed = listed_premises(issue, issues);
-  if (listed === 0) return [];
-  const read = await trusted_measure.read_trusted_body(String(issue));
-  if (read.kind === "refused") return listed === void 0 ? [] : [`not re-run: ${read.reason}`];
-  return measure_declaration.premises(read.body).flatMap((declaration) => checked(declaration, read) ?? []);
-}
-async function stop_text(issue, issues) {
-  const failed = await failed_premises(issue, issues);
-  if (failed.length === 0) return void 0;
-  return `premise: ${session_cite.issue(issue)}'s premises do not hold (${failed.join("; ")}), so the lane stops before implementing: park it with these values (backlogrun-park.md \u2192 "park and continue").`;
-}
-var lane_plan_premise = { stop_text };
-
-// scripts/lane/lane-plan-check.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var YIELD_EXIT_CODE = 2;
-var SPLIT_EXIT_CODE = 3;
-var PREMISE_EXIT_CODE = 4;
-var RELEASE_FLAG = "--release";
-var NEAR_CAP_HEADROOM = 20;
-function plan_of(argv, now) {
-  const [issue = "", ...paths] = argv;
-  const claims = [...backlog_overlap.path_claims(paths)];
-  if (!issue_number_shape.is_issue_number(issue) || claims.length === 0) return void 0;
-  return { issue: Number(issue), paths: claims, planned_at: now.toISOString() };
-}
-async function give_back(plan, clash, directory, at) {
-  const overlap = lane_plan_probe.overlap_text(plan.issue, clash);
-  lane_plan.record({ ...plan, yielded: true, waits_until: void 0 }, directory);
-  await lane_yield.record_yield(plan.issue, overlap, at);
-  await run_hold_cli.run([RELEASE_FLAG, String(plan.issue)]);
-  console.error(
-    `${overlap}, so it gives its lane back: end the session now, with no edit \u2014 \`run:merge\` closes the lane, and the issue is offered again once that lane ends.`
-  );
-  console.info("yield");
-  return YIELD_EXIT_CODE;
-}
-function clear_answer() {
-  console.info("clear");
-  return SUCCESS_EXIT_CODE;
-}
-function clear(plan, directory) {
-  lane_plan_probe.record_cleared(plan, directory);
-  return clear_answer();
-}
-function unread() {
-  console.error(auto_ok_cli.UNREADABLE_MESSAGE);
-  console.info("wait");
-  return FAILURE_EXIT_CODE;
-}
-function split(plan, over) {
-  console.error(lane_plan_size.refusal_text(plan.issue, over));
-  console.info("split");
-  return SPLIT_EXIT_CODE;
-}
-async function note(plan, over) {
-  const files = plan.paths.filter((file) => !test_declared_logic.is_test_file(file)).length;
-  const lines = over.reason === "lines" ? over.measured : 0;
-  await lane_ledger_write.record_split_notice({
-    issue: plan.issue,
-    files,
-    lines,
-    reason: over.reason
-  });
-}
-function is_dispatched(plan) {
-  return lane_child_marker.marked_issue() === String(plan.issue);
-}
-function is_split(plan, over) {
-  return over !== void 0 && !is_dispatched(plan) && !lane_plan_size.is_waived(plan, over);
-}
-function is_repeat(plan, directory) {
-  return is_dispatched(plan) && lane_plan.read(plan.issue, directory) !== void 0;
-}
-async function refusal(plan, over, directory) {
-  if (over === void 0 || is_repeat(plan, directory)) return void 0;
-  if (!is_dispatched(plan)) await note(plan, over);
-  if (is_split(plan, over)) return split(plan, over);
-  console.error(lane_plan_size.waiver_text(plan.issue, over));
-  return void 0;
-}
-async function warn_near_cap(plan, directory) {
-  const paths = plan.paths.map((file) => path.resolve(directory, file));
-  const budgets = await line_budget.budgets_for(paths, directory);
-  for (const { file_path, budget } of budgets) {
-    if (budget === void 0 || budget.headroom > NEAR_CAP_HEADROOM) continue;
-    console.error(
-      `near cap: ${path.relative(directory, file_path)} (${String(budget.headroom)} lines left)`
-    );
-  }
-}
-function sized_of(plan, issues) {
-  const is_judged = issues !== void 0 && lane_plan_size.declares(plan.issue, issues);
-  return is_judged ? { ...plan, sized: true } : plan;
-}
-function held(plan, clash, until) {
-  console.error(
-    `${lane_plan_probe.overlap_text(plan.issue, clash)}; this lane was dispatched first and holds commits, so it keeps its seat until ${until}: run this \`lane:plan\` again now \u2014 it waits inside, and answers \`clear\` once that lane ends, or \`yield\` past the deadline.`
-  );
-  console.info("wait");
-  return FAILURE_EXIT_CODE;
-}
-async function is_free(plan, directory) {
-  const issues = await lane_plan_probe.opted_in();
-  const running = issues === void 0 ? void 0 : lane_plan_probe.running_of(issues);
-  return running !== void 0 && lane_plan_probe.clash_among(plan, running, directory) === void 0;
-}
-async function settle(plan, clash, directory) {
-  const until = await lane_plan_wait_until.until(plan, clash.holder);
-  if (until === void 0) return await give_back(plan, clash, directory, "summary");
-  const waiting = { ...plan, waits_until: until };
-  lane_plan.record(waiting, directory);
-  const until_ms = Date.parse(until);
-  const end = await lane_plan_wait_event.timed(
-    { issue: plan.issue, holder: clash.holder },
-    async () => await lane_plan_wait.hold(until_ms, async () => await is_free(waiting, directory))
-  );
-  if (end === "free") return clear(waiting, directory);
-  return end === "expired" ? await give_back(waiting, clash, directory, "summary") : held(waiting, clash, until);
-}
-async function premise_stop(plan, issues, directory) {
-  if (lane_plan.read(plan.issue, directory) !== void 0) return void 0;
-  const stop = await lane_plan_premise.stop_text(plan.issue, issues);
-  if (stop === void 0) return void 0;
-  console.error(stop);
-  console.info("premise");
-  return PREMISE_EXIT_CODE;
-}
-async function check_plan(plan, directory) {
-  await warn_near_cap(plan, directory);
-  const issues = await lane_plan_probe.opted_in();
-  const refused = await refusal(plan, await lane_plan_probe.oversize_of(plan, issues, directory), directory) ?? await premise_stop(plan, issues, directory);
-  if (refused !== void 0) return refused;
-  const sized = sized_of(plan, issues);
-  lane_plan.record(sized, directory);
-  const found = lane_plan_probe.probe(sized, issues, directory);
-  if (lane_plan_probe.is_unread(found)) return unread();
-  return found === void 0 ? clear(sized, directory) : await settle(sized, found, directory);
-}
-async function probe_answer(plan, directory) {
-  const issues = await lane_plan_probe.opted_in();
-  const over = await lane_plan_probe.oversize_of(plan, issues, directory);
-  if (is_split(plan, over)) return split(plan, over);
-  const found = lane_plan_probe.probe(plan, issues, directory);
-  if (lane_plan_probe.is_unread(found)) return unread();
-  if (found === void 0) return clear_answer();
-  console.error(`${lane_plan_probe.overlap_text(plan.issue, found)}.`);
-  console.info("yield");
-  return YIELD_EXIT_CODE;
-}
-function placed(plan, directory) {
-  const recorded = lane_plan.read(plan.issue, directory);
-  if (recorded === void 0) return plan;
-  return {
-    ...plan,
-    size_approval: recorded.size_approval,
-    single: plan.single ?? recorded.single,
-    planned_at: recorded.planned_at,
-    yielded: recorded.yielded,
-    waits_until: recorded.waits_until,
-    sized: lane_plan.is_sized(recorded)
-  };
-}
-async function entry_plan(issue, issues, directory) {
-  const own = issues.filter((candidate) => candidate.number === issue);
-  const declared = await backlog_plan_comment.declared_of(own, directory);
-  const plan = plan_of([String(issue), ...declared.get(issue) ?? []], /* @__PURE__ */ new Date());
-  return plan === void 0 ? void 0 : placed(plan, directory);
-}
-async function entry_yield(issue, issues, directory) {
-  const plan = await entry_plan(issue, issues, directory);
-  const running = lane_plan_probe.running_of(issues);
-  const found = plan === void 0 ? void 0 : lane_plan_probe.clash_among(plan, running, directory);
-  if (plan === void 0 || found === void 0) return false;
-  await give_back(plan, found, directory, "entry");
-  return true;
-}
-async function yield_at_entry(issue, directory = process.cwd()) {
-  const issues = await lane_plan_probe.opted_in();
-  return issues === void 0 ? false : await entry_yield(issue, issues, directory);
-}
-var lane_plan_check = {
-  PREMISE_EXIT_CODE,
-  SPLIT_EXIT_CODE,
-  YIELD_EXIT_CODE,
-  check_plan,
-  placed,
-  plan_of,
-  probe_answer,
-  yield_at_entry
-};
-
-export {
-  lane_plan_check
-};

package/dist/commands/chunk-URDT2O2K.js

@@ -1,36 +0,0 @@
-import {
-  COMMAND_MAP
-} from "./chunk-C54QXJD6.js";
-import {
-  canonical_command
-} from "./chunk-ROJXMBXP.js";
-
-// scripts/josh/josh-read-only.ts
-var HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
-var ALL_FLAG = "--all";
-function is_help_request(command) {
-  return command === void 0 || command === ALL_FLAG || HELP_COMMANDS.has(command);
-}
-function entry_of(name) {
-  const command = canonical_command(name);
-  return Object.hasOwn(COMMAND_MAP, command) ? COMMAND_MAP[command] : void 0;
-}
-function is_read_only_call(entry, rest) {
-  const write_flags = entry.write_flags ?? [];
-  if (rest.some((argument) => write_flags.includes(argument.split("=", 1)[0] ?? ""))) return false;
-  if (entry.is_read_only === true) return true;
-  const flags = entry.read_only_flags ?? [];
-  return rest.some((argument) => flags.includes(argument));
-}
-function refusal(args) {
-  const [command = "", ...rest] = args;
-  if (is_help_request(args[0])) return void 0;
-  const entry = entry_of(command);
-  if (entry !== void 0 && is_read_only_call(entry, rest)) return void 0;
-  return `\`josh ${command}\` is not read-only: it carries a declared write flag, or its entry is not declared read-only and it carries no read-only flag its entry declares; read its usage with \`pnpm josh help ${command}\``;
-}
-var josh_read_only = { ALL_FLAG, entry_of, is_help_request, refusal };
-
-export {
-  josh_read_only
-};

package/dist/commands/chunk-UTHUX7VU.js

@@ -1,88 +0,0 @@
-import {
-  git_gh_issue
-} from "./chunk-YGFOGA7C.js";
-import {
-  git_gh_issue_rest
-} from "./chunk-ENKFCOVY.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  AUTO_OK_LABEL
-} from "./chunk-QQBMVC5W.js";
-
-// scripts/backlog/backlog-drive-listing.ts
-function numbers_of(body) {
-  const issues = git_gh_issue_rest.parse_rest_issues(body);
-  return new Set(
-    issues.filter((issue) => !git_gh_issue_rest.is_pull_request(issue)).map((issue) => issue.number)
-  );
-}
-function has_new(seen, numbers) {
-  if (seen === void 0) return false;
-  return [...numbers].some((number) => !seen.has(number));
-}
-function watcher() {
-  const memory = {};
-  function keep(numbers) {
-    memory.seen = numbers;
-  }
-  return async function is_changed() {
-    try {
-      const detail = await git_gh_issue.issue_list_label_first_page(AUTO_OK_LABEL);
-      const numbers = numbers_of(detail.body);
-      const is_new = has_new(memory.seen, numbers);
-      keep(numbers);
-      return is_new;
-    } catch {
-      keep(memory.seen ?? /* @__PURE__ */ new Set());
-      return false;
-    }
-  };
-}
-var backlog_drive_listing = {
-  watcher
-};
-
-// scripts/backlog/backlog-arrival-added.ts
-async function read_stream() {
-  const target = await run_event_stream_emit.stream_target();
-  return target === void 0 ? [] : run_event_stream.read_events(target);
-}
-function has_kind_since(events, kind, since_ms) {
-  return events.some((event) => event.kind === kind && Date.parse(event.at) >= since_ms);
-}
-async function is_kind_since(kind, since_ms, read) {
-  try {
-    return has_kind_since(await read(), kind, since_ms);
-  } catch {
-    return false;
-  }
-}
-async function is_added_since(since_ms, read = read_stream) {
-  return await is_kind_since(run_event_stream.EVENT_KIND.ADD, since_ms, read);
-}
-async function is_raised_since(since_ms, read = read_stream) {
-  return await is_kind_since(run_event_stream.EVENT_KIND.LANE_LIMIT, since_ms, read);
-}
-function tick_reader(read = read_stream) {
-  const memo = { pending: void 0 };
-  return {
-    read: async () => {
-      memo.pending ??= read();
-      return await memo.pending;
-    },
-    begin_tick: () => {
-      memo.pending = void 0;
-    }
-  };
-}
-var backlog_arrival_added = { has_kind_since, is_added_since, is_raised_since, tick_reader };
-
-export {
-  backlog_drive_listing,
-  backlog_arrival_added
-};

package/dist/commands/chunk-V4Z7G4UH.js

@@ -1,73 +0,0 @@
-import {
-  start_exec
-} from "./chunk-RH6ZWJOA.js";
-import {
-  git_location_environment,
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-
-// scripts/init/working-tree.ts
-var UNTRACKED_ARGUMENTS = ["ls-files", "--others", "--exclude-standard"];
-var MODIFIED_ARGUMENTS = ["diff", "--name-only", "--relative", "HEAD"];
-var INDEXED_ARGUMENTS = ["ls-files", "--cached"];
-var HISTORY_ARGUMENTS = ["rev-list", "--max-count=1", "--all"];
-var UNBORN_HEAD_EXIT_CODE = 1;
-var NOT_A_REPOSITORY = "not a git repository";
-function paths_of(output = "") {
-  return output.split("\0").filter((listed) => listed.length > 0);
-}
-function listing(args, root) {
-  return paths_of(start_exec.git_read([...args, "-z"], root));
-}
-function changed_paths(root) {
-  const untracked = listing(UNTRACKED_ARGUMENTS, root);
-  const modified = listing(MODIFIED_ARGUMENTS, root);
-  return [...untracked, ...modified];
-}
-function strict_listing(args, root) {
-  const output = start_exec.git_read([...args, "-z"], root);
-  if (output === void 0) throw new Error(`git ${args.join(" ")} failed in ${root}`);
-  return paths_of(output);
-}
-function head_state(root) {
-  const { exit_code, stderr } = git_spawn_sync.run(["rev-parse", "--verify", "--quiet", "HEAD"], {
-    cwd: root,
-    env: { ...git_spawn_sync.C_LOCALE, ...git_location_environment.location_free_environment() }
-  });
-  if (exit_code === 0) return "born";
-  if (stderr.includes(NOT_A_REPOSITORY)) return "absent";
-  if (exit_code === UNBORN_HEAD_EXIT_CODE) return "unborn";
-  throw new Error(`git rev-parse could not read HEAD in ${root}`);
-}
-function has_history(root) {
-  const output = start_exec.git_read(HISTORY_ARGUMENTS, root);
-  if (output === void 0) throw new Error(`git ${HISTORY_ARGUMENTS.join(" ")} failed in ${root}`);
-  return output.trim().length > 0;
-}
-function tracked_arguments(root) {
-  const state = head_state(root);
-  if (state === "born") return MODIFIED_ARGUMENTS;
-  if (state === "unborn" && has_history(root)) return INDEXED_ARGUMENTS;
-  return void 0;
-}
-function uncommitted_paths(root) {
-  const tracked = tracked_arguments(root);
-  if (tracked === void 0) return [];
-  const untracked = strict_listing(UNTRACKED_ARGUMENTS, root);
-  const modified = strict_listing(tracked, root);
-  return [...untracked, ...modified];
-}
-function dirty_tree_refusal(root, command) {
-  const paths = uncommitted_paths(root);
-  if (paths.length === 0) return void 0;
-  return [
-    `${command} refuses to run: the working tree has uncommitted changes.`,
-    ...paths.map((listed) => `  ${listed}`),
-    `Commit them, or stash them with \`git stash push -u -- .\`, then run ${command} again.`
-  ].join("\n");
-}
-var working_tree = { listing, changed_paths, uncommitted_paths, dirty_tree_refusal };
-
-export {
-  working_tree
-};

package/dist/commands/chunk-V5FD7DVV.js

@@ -1,48 +0,0 @@
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
-}
-async function tracked_names() {
-  const base = await change_base.resolved_through_merge();
-  if (base === void 0) {
-    return { tracked: to_paths(await git_command.diff_main_names()), base: "fallback" };
-  }
-  return { tracked: to_paths(await git_command.diff_names_since(base)), base: "merge_base" };
-}
-async function read_changed_parts() {
-  const { tracked, base } = await tracked_names();
-  const untracked = to_paths(await git_command.untracked_names());
-  return { tracked, untracked, base };
-}
-async function read_changed_paths(is_staged) {
-  if (is_staged) return to_paths(await git_command.diff_cached_names());
-  const { tracked, untracked } = await read_changed_parts();
-  return [...tracked, ...untracked];
-}
-async function read_changed_since(commit) {
-  const tracked = to_paths(await git_command.diff_names_since(commit));
-  const untracked = to_paths(await git_command.untracked_names());
-  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])];
-}
-async function read_held_at(commit, paths) {
-  if (paths.length === 0) return [];
-  return to_paths(await git_command.tree_names_at(commit, paths));
-}
-var changed_paths = {
-  read_changed_parts,
-  read_changed_paths,
-  read_changed_since,
-  read_held_at,
-  to_paths
-};
-
-export {
-  changed_paths
-};