@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-64II6P7B.js

@@ -0,0 +1,81 @@
+import {
+  lane_close
+} from "./chunk-MKIHWQ65.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/lane/lane-preserve.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+function preserved_comment(message, cause) {
+  return [
+    `The lane held uncommitted work when ${cause}, so it was stashed:`,
+    `- recover with \`pnpm josh stash:pop "${message}"\``
+  ].join("\n");
+}
+async function push_work(issue, directory, occasion) {
+  const message = git_stash.work_message(issue, occasion);
+  await git_stash.push(message, directory);
+  return message;
+}
+async function announce(issue, message, cause) {
+  await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause));
+}
+var KEEP_LOCK_PREFIX = "josh-lane-keep-lock-";
+var KEEP_LOCK_WAIT_MS = 6e4;
+var KEEP_LOCK_TIMEOUT = "another keep of this lane held the lock for the whole wait";
+function keep_lock_path(issue, directory) {
+  return repository_lock.lock_path(`${KEEP_LOCK_PREFIX}${issue}-`, directory);
+}
+async function stash_of(issue, directory, occasion) {
+  if (!await git_stash.has_work(directory)) return void 0;
+  return await push_work(issue, directory, occasion);
+}
+async function locked_stash_of(issue, directory, occasion) {
+  const kept = await repository_lock.with_lock(
+    async () => ({ stash: await stash_of(issue, directory, occasion) }),
+    keep_lock_path(issue, directory),
+    KEEP_LOCK_WAIT_MS
+  );
+  if (kept === void 0) return { kind: "unsaved", directory, reason: KEEP_LOCK_TIMEOUT };
+  return { kind: "saved", stash: kept.stash };
+}
+async function keep_work(issue, directory, occasion) {
+  try {
+    return await locked_stash_of(issue, directory, occasion);
+  } catch (error) {
+    return { kind: "unsaved", directory, reason: error_text.message_of(error) };
+  }
+}
+async function preserve_lane(issue, occasion, cause) {
+  const lane = await lane_close.resolve_lane(issue);
+  const { directory } = lane.targets;
+  if (!existsSync(path.join(directory, ".git"))) return true;
+  const kept = await keep_work(issue, directory, occasion);
+  if (kept.kind === "unsaved") {
+    console.error(
+      `${session_cite.issue(issue)}: uncommitted work could not be stashed \u2014 lane left at ${directory}`
+    );
+    return false;
+  }
+  if (kept.stash !== void 0) await announce(issue, kept.stash, cause);
+  return true;
+}
+var lane_preserve = { announce, keep_work, preserve_lane };
+
+export {
+  lane_preserve
+};

package/dist/commands/chunk-6DJT64DN.js

@@ -0,0 +1,342 @@
+import {
+  backlog_next_shared
+} from "./chunk-TJAGKUS2.js";
+import {
+  backlog_next
+} from "./chunk-SNXSRNFI.js";
+import {
+  backlog_wait_cause
+} from "./chunk-YSBLGTDZ.js";
+import {
+  epic_solo
+} from "./chunk-Z7R6JWN7.js";
+import {
+  josh_command
+} from "./chunk-72LAYP5S.js";
+import {
+  rule_value_cache
+} from "./chunk-QY7RITZQ.js";
+import {
+  backlogrun_launch
+} from "./chunk-3IXIYDC3.js";
+import {
+  run_event_setup
+} from "./chunk-WEEJU3EH.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/backlog/backlog-offer-cli.ts
+import { z } from "zod";
+
+// scripts/backlog/backlog-drain-flush.ts
+var FAILURE_PREFIX = "observations:flush skipped: ";
+var DURATION_PREFIX = "observations:flush finished in ";
+var FLUSH_COMMAND = "observations:flush";
+var OPTION = "drain-flush";
+var FLUSH_ARGV = { command: "pnpm", args: ["josh", "backlog:offer", `--${OPTION}`] };
+function report_failure(reason) {
+  console.error(`${FAILURE_PREFIX}${reason.replaceAll(/\s+/gu, " ")}`);
+}
+async function flush(now = Date.now) {
+  const started_ms = now();
+  try {
+    const root = await lane_registry.main_repository_root();
+    josh_command.require_success(await josh_command.josh_run_at(["main:sync"], root), "main:sync");
+    josh_command.require_success(
+      await josh_command.josh_run_at([FLUSH_COMMAND], root),
+      FLUSH_COMMAND
+    );
+  } catch (error) {
+    report_failure(error_text.message_of(error));
+  }
+  console.error(`${DURATION_PREFIX}${String((now() - started_ms) / MS_PER_SECOND)}s`);
+}
+function log_path_of(cwd) {
+  const common = git_common_directory.repository(cwd);
+  return common === void 0 ? void 0 : backlogrun_launch.log_path(common);
+}
+function start(cwd = process.cwd()) {
+  const launched = detached_launch.launch(
+    { argv: FLUSH_ARGV, cwd, log_path: log_path_of(cwd) },
+    report_failure
+  );
+  if (launched.kind === "failed") report_failure(launched.note);
+}
+var backlog_drain_flush = { OPTION, flush, start };
+
+// scripts/backlog/backlog-offer.ts
+var RETRY_LIMIT = 3;
+var FAILURE_EXIT_CODE = 1;
+var NO_RETRIES = 0;
+var TOKENS = backlog_next.VERDICT_TOKENS;
+var BLOCKED_ANSWER = "blocked";
+var SOLO_CAUSE = "solo";
+var VERDICT_ANSWERS = {
+  [TOKENS.complete]: "exhausted",
+  [TOKENS.error]: "unreadable",
+  [TOKENS.stop]: "parked",
+  [TOKENS.triage]: "untriaged"
+};
+function wait_answer(running) {
+  return running > 0 ? BLOCKED_ANSWER : "exhausted";
+}
+function verdict_answer(token, running) {
+  if (token === TOKENS.wait) return wait_answer(running);
+  return VERDICT_ANSWERS[token] ?? "unreadable";
+}
+function from_verdict(token, running, retries) {
+  if (token === TOKENS.retry) {
+    const next = retries + 1;
+    return { answer: next >= RETRY_LIMIT ? "unreadable" : "blocked", issues: [], retries: next };
+  }
+  return { answer: verdict_answer(token, running), issues: [], retries: NO_RETRIES };
+}
+function is_numbers(tokens) {
+  return tokens.length > 0 && tokens.every((token) => issue_number_shape.is_issue_number(token));
+}
+function without_triage(tokens) {
+  return tokens.at(-1) === TOKENS.triage ? tokens.slice(0, -1) : tokens;
+}
+function blocked_cause(error) {
+  if (epic_solo.is_solo_wait(error)) return { cause: SOLO_CAUSE };
+  const causes = backlog_wait_cause.parse(error);
+  const tag = backlog_wait_cause.tag_of(causes);
+  return tag === void 0 ? {} : {
+    cause: tag,
+    waiting: backlog_wait_cause.numbers_of(causes),
+    ...causes.not_before_ms !== void 0 && { not_before_ms: causes.not_before_ms }
+  };
+}
+function with_cause(offer, token, error) {
+  return token === TOKENS.wait ? { ...offer, ...blocked_cause(error) } : offer;
+}
+function answer_of(read, running, retries) {
+  if (read.code === FAILURE_EXIT_CODE) {
+    return { answer: "unreadable", issues: [], retries: NO_RETRIES };
+  }
+  const numbers = without_triage(read.tokens);
+  if (is_numbers(numbers)) {
+    const is_judgment_owed = numbers.length < read.tokens.length;
+    return { answer: "candidates", issues: numbers, retries: NO_RETRIES, is_judgment_owed };
+  }
+  const token = read.tokens[0] ?? "";
+  return with_cause(from_verdict(token, running, retries), token, read.err ?? "");
+}
+var backlog_offer = { RETRY_LIMIT, answer_of, verdict_answer, wait_answer };
+
+// scripts/backlog/backlog-offer-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE2 = 1;
+var JSON_KEY = "offer";
+var DEFAULT_COUNT = 0;
+var RUN_VERDICT = "run";
+var BUDGET_JSON_KEY = "budget";
+var WATCH_VERDICT = "watch";
+var STOP_VERDICT = "stop";
+var EXHAUSTED_ANSWER = "exhausted";
+var NO_RUNNING = 0;
+var DRAIN_TEXT = "backlog drained";
+var should_forward_stderr = true;
+var USAGE = "Usage: josh backlog:offer --started <ISO-8601> [--active <ISO-8601>] [--merged <n>] [--running <n>] [--max <n>] [--idle <minutes>] [--retries <n>] [--exclude <n>[,<n>...]]... [--repo <owner/repo>] [--json]";
+var OPTIONS = {
+  [backlog_drain_flush.OPTION]: { type: "boolean" },
+  active: { type: "string" },
+  exclude: { type: "string", multiple: true },
+  idle: { type: "string" },
+  json: { type: "boolean" },
+  max: { type: "string" },
+  merged: { type: "string" },
+  repo: { type: "string" },
+  retries: { type: "string" },
+  running: { type: "string" },
+  started: { type: "string" }
+};
+var FORWARDED = ["started", "active", "merged", "running", "max", "idle"];
+function read_values(argv) {
+  return cli_flags.values_of(argv, OPTIONS);
+}
+function count_of(raw) {
+  return raw === void 0 ? DEFAULT_COUNT : cli_flags.to_count(raw);
+}
+function counts_of(values) {
+  const running = count_of(cli_flags.string_of(values.running));
+  const retries = count_of(cli_flags.string_of(values.retries));
+  if (running === void 0 || retries === void 0) return void 0;
+  return { running, retries };
+}
+function excludes_of(values) {
+  const raw = values.exclude;
+  return Array.isArray(raw) ? raw.filter((value) => typeof value === "string") : [];
+}
+function next_argv(values) {
+  const repo = cli_flags.string_of(values.repo);
+  return [
+    "backlog:next",
+    ...excludes_of(values).flatMap((value) => ["--exclude", value]),
+    ...repo === void 0 ? [] : ["--repo", repo]
+  ];
+}
+function budget_argv(values, answer) {
+  const forwarded = FORWARDED.flatMap((name) => {
+    const value = cli_flags.string_of(values[name]);
+    return value === void 0 ? [] : [`--${name}`, value];
+  });
+  return ["backlog:budget", "--json", "--answer", answer, ...forwarded];
+}
+var budget_read_schema = z.object({
+  [BUDGET_JSON_KEY]: z.string(),
+  reason: z.string(),
+  is_finish: z.boolean(),
+  idle_until_ms: z.number().optional()
+});
+function budget_of(out) {
+  const read = json_value.parse_with(out, budget_read_schema);
+  if (read === void 0) return void 0;
+  return { ...read, verdict: read[BUDGET_JSON_KEY] };
+}
+function to_tokens(out) {
+  return out === "" ? [] : out.split("\n");
+}
+function issues_for(verdict, offer) {
+  return verdict === RUN_VERDICT ? offer.issues : [];
+}
+function emit(decision, offer, is_json) {
+  const { verdict, reason, is_finish } = decision;
+  const issues = issues_for(verdict, offer);
+  if (is_json) {
+    const payload = {
+      verdict,
+      issues,
+      answer: offer.answer,
+      cause: offer.cause,
+      waiting: offer.waiting,
+      not_before_ms: offer.not_before_ms,
+      idle_until_ms: decision.idle_until_ms,
+      is_judgment_owed: offer.is_judgment_owed,
+      retries: offer.retries,
+      reason,
+      is_finish
+    };
+    console.info(JSON.stringify({ [JSON_KEY]: payload }));
+    return SUCCESS_EXIT_CODE;
+  }
+  console.info(verdict);
+  for (const issue of issues) console.info(issue);
+  console.error(`retries: ${String(offer.retries)}`);
+  return SUCCESS_EXIT_CODE;
+}
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE2;
+}
+async function prepare_drain() {
+  await run_event_setup.emit(run_event_setup.STAGE.WATCHING);
+  backlog_drain_flush.start();
+}
+async function mark_drain(verdict, answer, running) {
+  if (answer !== EXHAUSTED_ANSWER || running !== NO_RUNNING) return false;
+  if (verdict !== WATCH_VERDICT && verdict !== STOP_VERDICT) return false;
+  return await run_event_stream_emit.emit_once(
+    run_event_stream.EVENT_KIND.DRAIN,
+    DRAIN_TEXT,
+    prepare_drain
+  );
+}
+function budget_edge(value) {
+  if (value === void 0) return "failed";
+  return value.verdict === WATCH_VERDICT || value.verdict === "triage" ? "waiting" : "done";
+}
+async function read_budget(values, offer) {
+  return await run_startup.phase(
+    "conditions",
+    async () => {
+      const result = await josh_command.josh_run(
+        budget_argv(values, offer.answer),
+        should_forward_stderr
+      );
+      return result.code === SUCCESS_EXIT_CODE ? budget_of(result.out) : void 0;
+    },
+    { edge_of: budget_edge }
+  );
+}
+function offer_edge(next, budget) {
+  const edge = backlog_next_shared.edge_of(next);
+  return edge === "done" ? budget_edge(budget) : edge;
+}
+async function decide(values, counts) {
+  const next = await run_startup.phase(
+    "candidates",
+    async () => await backlog_next_shared.read(next_argv(values), should_forward_stderr),
+    { edge_of: backlog_next_shared.edge_of }
+  );
+  const offer = backlog_offer.answer_of(
+    { code: next.code, tokens: to_tokens(next.out), err: next.err },
+    counts.running,
+    counts.retries
+  );
+  const decision = await read_budget(values, offer);
+  if (decision === void 0) return { code: FAILURE_EXIT_CODE2, edge: "failed" };
+  await mark_drain(decision.verdict, offer.answer, counts.running);
+  return { code: emit(decision, offer, values.json === true), edge: offer_edge(next, decision) };
+}
+async function flush_alone() {
+  await backlog_drain_flush.flush();
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const values = read_values(argv);
+  if (values === void 0) return refuse();
+  if (values[backlog_drain_flush.OPTION] === true) return await flush_alone();
+  rule_value_cache.emit();
+  const counts = counts_of(values);
+  if (counts === void 0) return refuse();
+  const result = await run_startup.phase("offer", async () => await decide(values, counts), {
+    root: true,
+    edge_of: (value) => value.edge
+  });
+  return result.code;
+}
+var backlog_offer_cli = {
+  JSON_KEY,
+  budget_argv,
+  counts_of,
+  next_argv,
+  read_values,
+  run
+};
+
+export {
+  backlog_offer,
+  backlog_offer_cli
+};

package/dist/commands/chunk-6HJ5CJSJ.js

@@ -0,0 +1,121 @@
+import {
+  lane_seed_policy
+} from "./chunk-6NGNMIMT.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-limit-override.ts
+var STREAM_START = 0;
+async function carry_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
+}
+function live_carry(target) {
+  const read = run_carry.read_carry(target);
+  return read.kind === "carried" ? read.carry : void 0;
+}
+async function current_carry() {
+  const target = await carry_target();
+  return target === void 0 ? void 0 : live_carry(target);
+}
+async function read_override() {
+  const carry = await current_carry();
+  return carry?.lane_limit;
+}
+function is_run_live(carry) {
+  return carry.is_handed_off === true || run_carry.is_owner_live(carry);
+}
+async function read_carried() {
+  const carry = await current_carry();
+  if (carry?.lane_limit !== void 0) return carry.lane_limit;
+  return carry !== void 0 && is_run_live(carry) ? carry.launch_limit : void 0;
+}
+async function update_carry(fields) {
+  const target = await carry_target();
+  const carry = target === void 0 ? void 0 : live_carry(target);
+  if (target === void 0 || carry === void 0) return false;
+  stamp_file.write_stamp(target, { ...carry, ...fields });
+  return true;
+}
+async function write_override(limit) {
+  return await update_carry({ lane_limit: limit });
+}
+async function write_launch(limit) {
+  return await update_carry({ launch_limit: limit });
+}
+async function emit_raise(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.LANE_LIMIT, text);
+}
+function never_raised() {
+  return false;
+}
+async function watch_raise() {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0) return never_raised;
+  const start = run_event_stream.read_from(target, STREAM_START).next_position;
+  return function is_raised() {
+    const { events } = run_event_stream.read_from(target, start);
+    return events.some((event) => event.kind === run_event_stream.EVENT_KIND.LANE_LIMIT);
+  };
+}
+var lane_limit_override = {
+  emit_raise,
+  read_carried,
+  read_override,
+  watch_raise,
+  write_launch,
+  write_override
+};
+
+// scripts/lane/lane-capacity.ts
+var DEFAULT_LANE_LIMIT = 4;
+var LANE_LIMIT_KEY = "JOSH_LANE_LIMIT";
+var NO_LANES = 0;
+function read_limit(raw, name) {
+  return cli_flags.read_positive_setting(raw, name, DEFAULT_LANE_LIMIT);
+}
+function environment_limit(environment = process.env) {
+  return read_limit(environment[LANE_LIMIT_KEY], LANE_LIMIT_KEY);
+}
+async function lane_limit(environment = process.env, read_carried2 = lane_limit_override.read_carried) {
+  const carried = await read_carried2();
+  if (carried !== void 0) return { kind: "limit", limit: carried };
+  return environment_limit(environment);
+}
+function seated_limit(limit) {
+  return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT);
+}
+function limit_room(limit, occupied) {
+  return Math.max(NO_LANES, seated_limit(limit) - occupied);
+}
+function free_lanes(limit, occupied, seated = occupied) {
+  const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated;
+  return Math.max(NO_LANES, Math.min(limit_room(limit, occupied), by_seats));
+}
+var lane_capacity = {
+  LANE_LIMIT_KEY,
+  environment_limit,
+  free_lanes,
+  lane_limit,
+  limit_room,
+  read_limit,
+  seated_limit
+};
+
+export {
+  lane_limit_override,
+  lane_capacity
+};

package/dist/commands/chunk-6LGMEJRN.js

@@ -0,0 +1,67 @@
+import {
+  issue_fold
+} from "./chunk-YDVFQL3G.js";
+import {
+  split_measure
+} from "./chunk-YUAIWKOM.js";
+import {
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  path_decision
+} from "./chunk-EYR2X5MZ.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-fold-cli.ts
+var USAGE = 'Usage: josh issue:fold "<title>" "<title>" \u2026 [--not-separable] [--json]';
+var JSON_KEY = "fold";
+var FAILURE_EXIT_CODE = 1;
+var REASONS = {
+  fold: "fold \u2014 file one Issue covering these findings; the split guide is not cleared, so they are one Issue however separable",
+  separate: "separate \u2014 file these apart; they are separable and their combined size clears the split guide",
+  "no-fold-needed": "no fold needed \u2014 a single candidate is filed on its own",
+  undetermined: 'undetermined \u2014 the diff measures no size, so the whole request\'s estimate decides (`split-assessment.md` \u2192 "The question")'
+};
+function read_arguments(argv) {
+  const parsed = cli_flags.parse_or_undefined({
+    args: [...argv],
+    options: { json: { type: "boolean" }, "not-separable": { type: "boolean" } },
+    allowPositionals: true
+  });
+  if (parsed === void 0) return void 0;
+  return {
+    titles: parsed.positionals,
+    is_separable: parsed.values["not-separable"] !== true,
+    is_json: parsed.values.json === true
+  };
+}
+async function size_verdict() {
+  try {
+    const measurement = await split_measure.read_branch();
+    return measurement.files === 0 ? void 0 : measurement.verdict;
+  } catch {
+    return void 0;
+  }
+}
+async function size_for(args) {
+  if (args.titles.length < issue_fold.MIN_CANDIDATES) return split_assess.SINGLE_VERDICT;
+  return await size_verdict();
+}
+async function run(argv) {
+  const args = read_arguments(argv);
+  if (args === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const size = await size_for(args);
+  const verdict = issue_fold.fold_verdict(args.titles.length, args.is_separable, size);
+  path_decision.print_decision(JSON_KEY, verdict, REASONS[verdict], args.is_json);
+  return 0;
+}
+var issue_fold_cli = { REASONS, read_arguments, size_verdict, run };
+
+export {
+  issue_fold_cli
+};