@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-WEEJU3EH.js

@@ -0,0 +1,109 @@
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/run/event/run-event-setup.ts
+var STAGE = {
+  // `josh backlogrun` started the parent session, which is reading its procedure.
+  STARTING: "starting session",
+  // `run:carry --begin` claimed the run, and the parent is planning it.
+  PLANNING: "planning",
+  // The supervisor took the run over from the parent and is asking for the first offer.
+  HANDING_OFF: "handing off",
+  // No child is runnable; maintenance may still be finishing before the replaceable drain.
+  WATCHING: "watching",
+  // The driver answered something only a session can act on — an untriaged child, an epic left to a
+  // person — and the supervisor is waking one. The next hand-off replaces it.
+  JUDGING: "waiting on judgment",
+  // The supervisor started that session, which is now acting on the driver's answer. It is detached, so
+  // its end is the supervisor's next hand-off, which replaces this.
+  SESSION: "judgment session running",
+  // The driver read a drain owing the retrospective and is waiting on the retrospective unit it
+  // started (joshuafolkken/kit#6745). The unit's end is the driver's next stage, which replaces this.
+  RETROSPECTIVE: "retrospective",
+  // The driver's launch of a lane returned without a child: no lane was free to open, or a step after
+  // the open failed. Written through `no_child`, naming its issue, so it ends that lane's stage alone
+  // while the pass's other launches run on (joshuafolkken/kit#5519).
+  NO_CHILD: "no child launched"
+};
+var OPENING = "opening lane";
+var INSTALLING = "installing dependencies";
+var DISPATCHING = "dispatching";
+var LANE_STAGE = { OPENING, INSTALLING, DISPATCHING };
+function opening_lane(issue) {
+  return `${OPENING} ${issue_cite.plain_for("program", issue)}`;
+}
+function installing(issue) {
+  return `${INSTALLING} ${issue_cite.plain_for("program", issue)}`;
+}
+function dispatching(issue) {
+  return `${DISPATCHING} ${issue_cite.plain_for("program", issue)}`;
+}
+function no_child(issue) {
+  return `${STAGE.NO_CHILD} ${issue_cite.plain_for("program", issue)}`;
+}
+async function emit(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text);
+}
+function append_stage(resolve_target, text, at) {
+  try {
+    const { SETUP } = run_event_stream.EVENT_KIND;
+    run_event_stream.append(resolve_target(), SETUP, text, at.toISOString());
+  } catch (error) {
+    error_text.trace_swallowed("run_event_setup.append_stage", error);
+  }
+}
+function emit_in(repository, text, at) {
+  append_stage(() => run_event_stream.target_of(repository), text, at);
+}
+function emit_to(target, text, at) {
+  append_stage(() => target, text, at);
+}
+function is_stage(event, prefix) {
+  return event.kind === run_event_stream.EVENT_KIND.SETUP && event.text.startsWith(prefix);
+}
+function first_lane_span(start, later) {
+  const next_start = later.findIndex((event) => is_stage(event, STAGE.STARTING));
+  const session = next_start === -1 ? later : later.slice(0, next_start);
+  const opening = session.find((event) => is_stage(event, OPENING));
+  return {
+    from_ms: Date.parse(start.at),
+    end_ms: opening === void 0 ? void 0 : Date.parse(opening.at)
+  };
+}
+function first_lane_spans(events) {
+  return events.flatMap(
+    (event, index) => is_stage(event, STAGE.STARTING) ? [first_lane_span(event, events.slice(index + 1))] : []
+  );
+}
+function first_lane_ms(events) {
+  const span = first_lane_spans(events).at(-1);
+  return span?.end_ms === void 0 ? void 0 : span.end_ms - span.from_ms;
+}
+var run_event_setup = {
+  LANE_STAGE,
+  STAGE,
+  dispatching,
+  emit,
+  emit_in,
+  emit_to,
+  first_lane_ms,
+  first_lane_spans,
+  installing,
+  is_stage,
+  no_child,
+  opening_lane
+};
+
+export {
+  run_event_setup
+};

package/dist/commands/chunk-WHXGUOYP.js

@@ -0,0 +1,48 @@
+import {
+  backlog_drive_restore
+} from "./chunk-52CGT2IN.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/backlog/backlog-drive-adopt.ts
+async function active_lanes() {
+  const active = backlog_drive_restore.active_issues(await run_event_stream_emit.current_events());
+  const lanes = await lane_registry.list_lanes();
+  return lanes.filter((lane) => !lane.is_stranded && active.has(lane.issue));
+}
+function adopted_note(issue) {
+  return `${issue_cite.plain_for("program", issue)} adopted by backlog:drive: its lane was launched outside the loop`;
+}
+async function note_adopted(issue) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.NOTE, adopted_note(issue));
+}
+async function adoptable(in_flight) {
+  const lanes = await active_lanes();
+  const issues = lanes.map((lane) => lane.issue).filter((issue) => !in_flight.includes(issue));
+  await Promise.all(
+    issues.map(async (issue) => {
+      await note_adopted(issue);
+    })
+  );
+  return issues;
+}
+async function held(state, should_offer, ports) {
+  if (!should_offer || state.is_stopping) return state;
+  const adopting = await ports.adoptable(state.in_flight);
+  return adopting.length === 0 ? state : { ...state, in_flight: [...state.in_flight, ...adopting] };
+}
+var backlog_drive_adopt = { active_lanes, adoptable, held };
+
+export {
+  backlog_drive_adopt
+};

package/dist/commands/chunk-WHYYBPIC.js

@@ -0,0 +1,113 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-B7UY7EOD.js";
+import {
+  ISSUE_FIELDS,
+  STATE_AND_RELATIONS_FIELDS,
+  git_gh_issue_graphql,
+  git_gh_issue_rest,
+  issue_fields_schema
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-batch-graphql.ts
+import { z } from "zod";
+var ALIAS_PREFIX = "issue";
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+var repository_schema = z.record(z.string(), z.unknown());
+var data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
+var response_schema = z.looseObject({ data: data_schema });
+function alias_of(issue_number) {
+  return `${ALIAS_PREFIX}${String(issue_number)}`;
+}
+function query_of(issue_numbers) {
+  const aliases = issue_numbers.map(
+    (issue_number) => `${alias_of(issue_number)}: issueOrPullRequest(number: ${String(issue_number)}) { ... on Issue { ${ISSUE_FIELDS} } }`
+  );
+  return `query($owner: String!, $name: String!) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
+}`;
+}
+function answered(json) {
+  return { kind: "read", json };
+}
+function to_read(issue, fields) {
+  const issue_json = git_gh_issue_rest.to_gh_issue(
+    git_gh_issue_graphql.to_rest_issue(issue),
+    git_gh_issue_rest.split_fields(fields),
+    git_gh_issue_graphql.to_blocked_by(issue)
+  );
+  return answered(JSON.stringify(issue_json));
+}
+async function query_chunk(issue_numbers, variables) {
+  const json = await git_gh_transport.query_partial({ query: query_of(issue_numbers), variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, response_schema)?.data;
+}
+function answered_reads(request, data) {
+  return request.issue_numbers.flatMap((issue_number) => {
+    const issue = issue_fields_schema.safeParse(data.repository[alias_of(issue_number)]);
+    return issue.success ? [[issue_number, to_read(issue.data, request.fields)]] : [];
+  });
+}
+function with_chunk(batch, request, data) {
+  if (data === void 0) return batch;
+  return {
+    reads: new Map([...batch.reads, ...answered_reads(request, data)]),
+    cost: batch.cost + data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+function empty_batch() {
+  return { reads: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
+}
+async function read_many(issue_numbers, repo, fields = STATE_AND_RELATIONS_FIELDS) {
+  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
+  let batch = empty_batch();
+  if (variables === void 0) return batch;
+  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
+  for (const chunk of chunks) {
+    const request = { issue_numbers: chunk, fields };
+    batch = with_chunk(batch, request, await query_chunk(chunk, variables));
+  }
+  return batch;
+}
+var git_gh_issue_batch_graphql = { answered, empty_batch, read_many };
+
+// scripts/gh/git-gh-issue-batch-read.ts
+async function read_each(issue_numbers, reader) {
+  const { reads } = await git_gh_issue_batch_graphql.read_many(
+    issue_numbers,
+    reader.repo,
+    reader.fields
+  );
+  return await Promise.all(
+    issue_numbers.map(async (issue_number) => {
+      const read = reads.get(issue_number);
+      const value = read?.kind === "read" ? reader.from_json(read.json) : await reader.read_rest(issue_number);
+      return [issue_number, value];
+    })
+  );
+}
+async function read_across(issues, reader_for) {
+  const repos = [...new Set(issues.map((issue) => issue.repo))];
+  const reads = await Promise.all(
+    repos.map(async (repo) => {
+      const numbers = issues.filter((issue) => issue.repo === repo).map((issue) => issue.number);
+      return new Map(await read_each(numbers, reader_for(repo)));
+    })
+  );
+  return issues.map((issue) => reads[repos.indexOf(issue.repo)]?.get(issue.number));
+}
+var git_gh_issue_batch_read = { read_across, read_each };
+
+export {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+};

package/dist/commands/chunk-WKXMY7MW.js

@@ -0,0 +1,84 @@
+import {
+  review_brief
+} from "./chunk-5ZWU2B7T.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+
+// scripts/gate/gate-skip.ts
+var FORCE_FLAG = "--force";
+var NO_BASE = "the merge base could not be read";
+var NO_CHANGE = "no file differs from the merge base";
+var INPUTS_MOVED = "a checked tool or environment variable changed since the green gate";
+var BASE_MOVED = "the merge base moved since the green gate";
+function base_moved(recorded, base) {
+  return `${BASE_MOVED} (${recorded ?? "none"} \u2192 ${base})`;
+}
+function stamp_miss(stamp, base) {
+  if (stamp.base !== base) return base_moved(stamp.base, base);
+  return review_stamps.gate_stamp.describes_inputs(stamp) ? void 0 : INPUTS_MOVED;
+}
+var NO_MATCHING_RECORD = "no green gate record matches the changed files";
+function record_miss(recorded, tree) {
+  if (recorded === void 0) return NO_MATCHING_RECORD;
+  const changed = String(Object.keys(tree).length);
+  const covered = String(Object.keys(recorded.files).length);
+  const differing = String(file_map_stamp.changed_since(recorded, tree).length);
+  return `${NO_MATCHING_RECORD} (${changed} changed, record covers ${covered}, ${differing} differ)`;
+}
+function gate_reuse(tree, base, source) {
+  if (base === void 0) return { miss: NO_BASE };
+  if (Object.keys(tree).length === 0) return { miss: NO_CHANGE };
+  const recorded = review_stamps.gate_stamp.read(source);
+  const stamp = review_brief.matching_stamp(recorded, tree);
+  if (stamp === void 0) return { miss: record_miss(recorded, tree) };
+  const miss = stamp_miss(stamp, base);
+  return miss === void 0 ? { stamp } : { miss };
+}
+var MISS_KINDS = [
+  [NO_BASE, "no-base"],
+  [NO_CHANGE, "no-change"],
+  [`${NO_MATCHING_RECORD} (`, "record-differs"],
+  [NO_MATCHING_RECORD, "no-record"],
+  [BASE_MOVED, "base-moved"],
+  [INPUTS_MOVED, "inputs-moved"]
+];
+var OTHER_MISS = "other";
+function miss_kind(miss) {
+  return MISS_KINDS.find(([prefix]) => miss.startsWith(prefix))?.[1] ?? OTHER_MISS;
+}
+function stamp_of(reuse) {
+  return "stamp" in reuse ? reuse.stamp : void 0;
+}
+function reusable_green_gate(tree, base, source) {
+  return stamp_of(gate_reuse(tree, base, source));
+}
+function format_reuse_notice(notice) {
+  return `\u2714 this tree is already green \u2014 ${notice.subject} passed on it at ${notice.taken_at} (\`pnpm josh gate\`)${notice.carried_clause}.
+  Reusing that result; nothing was re-run. \`${notice.force_hint}\` runs ${notice.rerun_object} anyway.`;
+}
+function format_skip(taken_at) {
+  return format_reuse_notice({
+    subject: "lint, the type check, the spell check and the unit tests all",
+    carried_clause: "",
+    taken_at,
+    force_hint: `pnpm josh gate ${FORCE_FLAG}`,
+    rerun_object: "the four checks"
+  });
+}
+var gate_skip = {
+  FORCE_FLAG,
+  format_reuse_notice,
+  format_skip,
+  gate_reuse,
+  miss_kind,
+  reusable_green_gate,
+  stamp_of
+};
+
+export {
+  gate_skip
+};

package/dist/commands/chunk-WPSCCUTE.js

@@ -0,0 +1,119 @@
+import {
+  bash_triggers
+} from "./chunk-25LVQDOF.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  git_argv
+} from "./chunk-ZEVI2ZGI.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+
+// scripts/gate/command-memory.ts
+import os from "node:os";
+var JOSH_PROGRAM = "josh";
+var RESERVED_RUN = "reserved-run";
+var COMMAND_SEPARATOR = "--";
+var ESLINT = "eslint";
+var VITEST = "vitest";
+var AUTO_WORKERS = "auto";
+var LINE_BREAK = "\n";
+var SHELL_HEREDOC = /\b(?:ba|z|da|k)?sh(?:\s+-\w+)*\s*<<-?\s*(['"]?)(\w+)\1/u;
+var HEREDOC_DELIMITER_GROUP = 2;
+var AUTO_CORE_SHARE = 2;
+var SINGLE_WORKER = 1;
+var WORKER_FLAGS = {
+  [ESLINT]: "--concurrency",
+  [VITEST]: "--maxWorkers"
+};
+function wrapped_command_of(call) {
+  if (call.name !== JOSH_PROGRAM || call.args[0] !== RESERVED_RUN) return void 0;
+  const separator = call.args.indexOf(COMMAND_SEPARATOR);
+  return separator === -1 ? void 0 : call.args.slice(separator + 1).join(" ");
+}
+function reading_of(segment, is_reserved) {
+  const call = git_argv.program_of(segment);
+  const wrapped = call === void 0 ? void 0 : wrapped_command_of(call);
+  if (wrapped !== void 0) return { line: wrapped, is_reserved: true };
+  const script = bash_triggers.shell_script_of(segment);
+  if (script !== void 0) return { line: script, is_reserved };
+  return call === void 0 ? void 0 : { ...call, is_reserved };
+}
+function body_until(lines, delimiter) {
+  const end = lines.findIndex((body_line) => body_line.trim() === delimiter);
+  return (end === -1 ? lines : lines.slice(0, end)).join(LINE_BREAK);
+}
+function shell_heredoc_bodies(line) {
+  const lines = line.split(LINE_BREAK);
+  return lines.flatMap((opening, index) => {
+    const delimiter = SHELL_HEREDOC.exec(opening)?.[HEREDOC_DELIMITER_GROUP];
+    return delimiter === void 0 ? [] : body_until(lines.slice(index + 1), delimiter);
+  });
+}
+function is_tool_call(reading) {
+  return "name" in reading;
+}
+function is_pending_line(reading) {
+  return !is_tool_call(reading);
+}
+function tool_calls_of(line) {
+  const pending = [{ line, is_reserved: false }];
+  const calls = [];
+  for (let next = pending.shift(); next !== void 0; next = pending.shift()) {
+    const { is_reserved } = next;
+    const readings = shell_segments.quote_aware_commands_of(time_shell.without_heredoc_bodies(next.line)).flatMap((segment) => reading_of(segment, is_reserved) ?? []);
+    const bodies = shell_heredoc_bodies(next.line).map((body) => ({ line: body, is_reserved }));
+    calls.push(...readings.filter((reading) => is_tool_call(reading)));
+    pending.push(...readings.filter((reading) => is_pending_line(reading)), ...bodies);
+  }
+  return calls;
+}
+function flag_value(args, flag) {
+  const prefix = `${flag}=`;
+  const index = args.findIndex((argument2) => argument2 === flag || argument2.startsWith(prefix));
+  const argument = args[index];
+  if (argument === void 0) return void 0;
+  return argument === flag ? args[index + 1] : argument.slice(prefix.length);
+}
+function default_workers(name, cores) {
+  return name === VITEST ? Math.max(SINGLE_WORKER, cores - 1) : SINGLE_WORKER;
+}
+function count_of(value, cores) {
+  if (value === AUTO_WORKERS) return Math.max(SINGLE_WORKER, Math.floor(cores / AUTO_CORE_SHARE));
+  const count = Number(value);
+  return Number.isSafeInteger(count) && count > SINGLE_WORKER ? count : SINGLE_WORKER;
+}
+function workers_of(call, cores = os.availableParallelism()) {
+  const flag = WORKER_FLAGS[call.name];
+  const value = flag === void 0 ? void 0 : flag_value(call.args, flag);
+  return value === void 0 ? default_workers(call.name, cores) : count_of(value, cores);
+}
+function memory_of(call, cores) {
+  const row = core_weights.TOOL_MEMORY[call.name];
+  return row === void 0 ? void 0 : core_weights.MEMORY_MB[row] * workers_of(call, cores);
+}
+function estimated_memory_mb(line, cores = os.availableParallelism()) {
+  const amounts = tool_calls_of(line).flatMap((call) => memory_of(call, cores) ?? []);
+  return amounts.length === 0 ? void 0 : Math.max(...amounts);
+}
+function runs_multi_worker_eslint(line, cores = os.availableParallelism()) {
+  return tool_calls_of(line).some(
+    (call) => call.name === ESLINT && workers_of(call, cores) > SINGLE_WORKER
+  );
+}
+var command_memory = {
+  estimated_memory_mb,
+  runs_multi_worker_eslint,
+  tool_calls_of,
+  workers_of,
+  wrapped_command_of
+};
+
+export {
+  command_memory
+};