@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-IXZZSST7.js

@@ -0,0 +1,459 @@
+import {
+  create_spawn_error,
+  git_push_transport,
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG
+} from "./chunk-B5GXZK3E.js";
+import {
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-diff-reads.ts
+var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
+var NAME_ONLY_FLAG = "--name-only";
+var DEFAULT_BRANCH_FALLBACK = "main";
+var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
+function default_branch_of(output) {
+  const trimmed = output?.trim() ?? "";
+  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
+  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+}
+async function get_default_branch() {
+  try {
+    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
+  } catch {
+    return DEFAULT_BRANCH_FALLBACK;
+  }
+}
+var MERGE_BASE_COMMAND = "merge-base";
+function reference_check_arguments(reference) {
+  return ["rev-parse", "--verify", "--quiet", reference];
+}
+function remote_reference_of(default_branch) {
+  return `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
+}
+async function reference_exists(reference) {
+  try {
+    await git_spawn.read([...reference_check_arguments(reference)]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function default_branch_reference() {
+  const default_branch = await get_default_branch();
+  const remote_reference = remote_reference_of(default_branch);
+  return await reference_exists(remote_reference) ? remote_reference : default_branch;
+}
+function merge_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "HEAD"];
+}
+function incoming_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "MERGE_HEAD"];
+}
+function later_base_arguments(base, incoming) {
+  return [MERGE_BASE_COMMAND, "--independent", base, incoming];
+}
+function later_base_of(output, base) {
+  const [later = ""] = output?.split("\n", 1) ?? [];
+  return later === "" ? base : later;
+}
+async function change_base() {
+  const default_branch = await default_branch_reference();
+  try {
+    return await git_spawn.read([...merge_base_arguments(default_branch)]);
+  } catch {
+    return default_branch;
+  }
+}
+async function diff_main(file_path) {
+  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
+}
+var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
+var NO_RELATIVE_PATHS = "--no-relative";
+var NO_RENAME_DETECTION = "--no-renames";
+async function change_base_commit() {
+  return await git_spawn.read(["rev-parse", await change_base()]);
+}
+function names_since_arguments(commit2) {
+  return [
+    ...NO_PATH_QUOTING,
+    "diff",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    commit2,
+    "--"
+  ];
+}
+async function diff_names_since(commit2) {
+  return await git_spawn.read([...names_since_arguments(commit2)]);
+}
+async function tree_names_at(commit2, paths) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "ls-tree",
+    "-r",
+    NAME_ONLY_FLAG,
+    "--full-tree",
+    commit2,
+    "--",
+    ...paths
+  ]);
+}
+async function diff_main_names() {
+  return await diff_names_since(await change_base());
+}
+async function diff_cached_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--cached",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION
+  ]);
+}
+async function diff_numstat_since(base) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--numstat",
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    base,
+    "--"
+  ]);
+}
+var WHOLE_TREE_PATHSPEC = ":/";
+var UNTRACKED_ARGUMENTS = [
+  ...NO_PATH_QUOTING,
+  "ls-files",
+  "--others",
+  "--exclude-standard",
+  "--full-name",
+  WHOLE_TREE_PATHSPEC
+];
+async function untracked_names() {
+  return await git_spawn.read([...UNTRACKED_ARGUMENTS]);
+}
+var git_diff_reads = {
+  DEFAULT_BRANCH_ARGUMENTS,
+  UNTRACKED_ARGUMENTS,
+  change_base,
+  change_base_commit,
+  default_branch_of,
+  default_branch_reference,
+  diff_cached_names,
+  diff_main,
+  diff_main_names,
+  diff_numstat_since,
+  diff_names_since,
+  get_default_branch,
+  incoming_base_arguments,
+  later_base_arguments,
+  later_base_of,
+  merge_base_arguments,
+  names_since_arguments,
+  reference_check_arguments,
+  remote_reference_of,
+  tree_names_at,
+  untracked_names
+};
+
+// scripts/git/git-pre-push-hook.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var REMOTE = "origin";
+var HOOK_NAME = "pre-push";
+var PROBE_HOOK_NAME = "kit-hook-run-probe";
+var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
+var HOOK_RUN = "run";
+var STDIN_FILE = "refs";
+var TEMPORARY_PREFIX = "kit-pre-push-";
+var ZERO_DIGIT = "0";
+async function read_remote_oid(branch2) {
+  try {
+    return await git_spawn.read([
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/remotes/${REMOTE}/${branch2}`
+    ]);
+  } catch {
+    return void 0;
+  }
+}
+async function read_push_references() {
+  const [branch2, local_oid] = await Promise.all([
+    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
+    git_spawn.read(["rev-parse", "HEAD"])
+  ]);
+  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
+}
+function to_stdin_line(references) {
+  const reference = `refs/heads/${references.branch}`;
+  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
+  return `${reference} ${references.local_oid} ${reference} ${remote_oid}
+`;
+}
+function to_hook_run_arguments(stdin_path, hook_name) {
+  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
+}
+async function can_probe(probe_arguments) {
+  try {
+    await git_spawn.read(["hook", ...probe_arguments]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function can_run_hooks(stdin_path) {
+  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
+  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
+  return await can_probe([HOOK_RUN, ...options]);
+}
+async function run_with_stdin(stdin_line) {
+  const directory = await mkdtemp(path.join(tmpdir(), TEMPORARY_PREFIX));
+  const stdin_path = path.join(directory, STDIN_FILE);
+  try {
+    await writeFile(stdin_path, stdin_line);
+    if (!await can_run_hooks(stdin_path)) return false;
+    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
+    await git_spawn.with_output(
+      "hook",
+      [...to_hook_run_arguments(stdin_path, HOOK_NAME), "--", REMOTE, url],
+      { timeout_ms: SUITE_TIMEOUT_MS }
+    );
+    return true;
+  } finally {
+    await rm(directory, { force: true, recursive: true });
+  }
+}
+async function run() {
+  const references = await read_push_references();
+  if (references.local_oid === references.remote_oid) return true;
+  return await run_with_stdin(to_stdin_line(references));
+}
+var git_pre_push_hook = {
+  run
+};
+
+// scripts/git/git-command.ts
+var BRANCH_ARGUMENTS = ["rev-parse", "--abbrev-ref", "HEAD"];
+async function branch() {
+  return await git_spawn.read([...BRANCH_ARGUMENTS]);
+}
+async function branch_at(directory) {
+  return await git_spawn.read(["-C", directory, ...BRANCH_ARGUMENTS]);
+}
+async function status(directory) {
+  const location = directory === void 0 ? [] : ["-C", directory];
+  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
+}
+async function repository_root() {
+  const result = git_spawn_sync.toplevel();
+  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
+  return result.stdout.trim();
+}
+async function head_commit() {
+  return await git_spawn.read(["rev-parse", "HEAD"]);
+}
+var GIT_DIRECTORY_ARGUMENTS = [
+  "rev-parse",
+  "--absolute-git-dir",
+  "--path-format=absolute",
+  "--git-common-dir"
+];
+async function git_directories() {
+  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
+  return output.split("\n").filter((line) => line !== "");
+}
+async function diff_cached(file_path) {
+  return await git_spawn.read(["diff", "--cached", file_path]);
+}
+async function fetch_branch(branch_name) {
+  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
+  return await git_spawn.read_remote(["fetch", "origin", refspec]);
+}
+async function merge_fast_forward(branch_name) {
+  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`], SUITE_TIMEOUT_MS);
+}
+async function fast_forward_local(branch_name) {
+  return await git_spawn.read_remote(["fetch", "origin", `${branch_name}:${branch_name}`]);
+}
+async function merge_branch(branch_name, message) {
+  const message_arguments = message === void 0 ? [] : ["-m", message];
+  await git_spawn.with_output("merge", [...message_arguments, `origin/${branch_name}`], {
+    timeout_ms: SUITE_TIMEOUT_MS
+  });
+}
+async function checkout_b(branch_name) {
+  return await git_spawn.read(["checkout", "-b", branch_name], SUITE_TIMEOUT_MS);
+}
+async function checkout(branch_name) {
+  return await git_spawn.read(["checkout", branch_name], SUITE_TIMEOUT_MS);
+}
+async function commit(message) {
+  await git_spawn.with_output("commit", ["-m", message], { timeout_ms: SUITE_TIMEOUT_MS });
+}
+async function delete_branch(branch_name) {
+  await git_spawn.read(["branch", "-d", branch_name]);
+}
+async function read_commit_count(revisions) {
+  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
+  const parsed = Number(output);
+  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
+  throw new Error(
+    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
+  );
+}
+async function commit_count_beyond(base, tip) {
+  return await read_commit_count([`${base}..${tip}`]);
+}
+async function commit_count_unpushed(branch_name) {
+  return await read_commit_count([branch_name, "--not", "--remotes"]);
+}
+function is_exit_code_128(cause) {
+  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
+}
+function is_upstream_not_set_error(error) {
+  if (!(error instanceof Error)) return false;
+  const { cause } = error;
+  return cause !== void 0 && is_exit_code_128(cause);
+}
+var NO_VERIFY_FLAG = "--no-verify";
+async function push_with_upstream(branch_name, verify_flags) {
+  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
+}
+async function push() {
+  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
+  try {
+    await git_push_transport.push([...verify_flags]);
+  } catch (error) {
+    if (is_upstream_not_set_error(error)) {
+      const current_branch = await branch();
+      await push_with_upstream(current_branch, verify_flags);
+      return;
+    }
+    throw error;
+  }
+}
+async function pull_fast_forward() {
+  await git_spawn.with_output_remote("pull", ["--ff-only"]);
+}
+var SHORT_NAME_FORMAT = "--format=%(refname:short)";
+var REMOTES_FLAG = "--remotes";
+async function list_branches(flags, pattern) {
+  try {
+    const output = await git_spawn.read([
+      "branch",
+      "--list",
+      SHORT_NAME_FORMAT,
+      ...flags,
+      pattern
+    ]);
+    return output.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function branch_names(pattern) {
+  return await list_branches([], pattern);
+}
+async function branch_names_remote(pattern) {
+  return await list_branches([REMOTES_FLAG], pattern);
+}
+async function branch_exists(branch_name) {
+  const names = await branch_names(branch_name);
+  return names.length > 0;
+}
+var ALL_PATHS_PATHSPEC = ":/";
+function exclude_pathspec(file_path) {
+  return `:(exclude,top)${file_path}`;
+}
+async function add_tracked(excluded_paths) {
+  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
+  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
+}
+async function add_path(file_path) {
+  await git_spawn.with_output("add", ["--", file_path]);
+}
+var FIRST_PARENT_FLAG = "--first-parent";
+async function log_first_parent(limit, file_path, tip = "HEAD") {
+  const output = await git_spawn.read([
+    "log",
+    FIRST_PARENT_FLAG,
+    "--format=%H",
+    `-n`,
+    String(limit),
+    tip,
+    "--",
+    file_path
+  ]);
+  return output.split("\n").filter((line) => line.length > 0);
+}
+async function show_file(spec) {
+  return await git_spawn.read(["show", spec]);
+}
+var MERGE_COUNT_ARGUMENTS = [
+  "rev-list",
+  "--count",
+  "--merges",
+  FIRST_PARENT_FLAG
+];
+function merge_count_arguments(range) {
+  return [...MERGE_COUNT_ARGUMENTS, range];
+}
+async function count_merges(range) {
+  const output = await git_spawn.read(merge_count_arguments(range));
+  const parsed = Number(output.trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var git_command = {
+  GIT_DIRECTORY_ARGUMENTS,
+  branch,
+  branch_at,
+  status,
+  repository_root,
+  head_commit,
+  git_directories,
+  diff_cached,
+  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s,
+  // re-exported here so no call site, mock or spy moved with them.
+  ...git_diff_reads,
+  fetch_branch,
+  merge_fast_forward,
+  fast_forward_local,
+  merge_branch,
+  checkout_b,
+  checkout,
+  commit,
+  commit_count_beyond,
+  commit_count_unpushed,
+  delete_branch,
+  push,
+  pull_fast_forward,
+  branch_exists,
+  branch_names,
+  branch_names_remote,
+  add_tracked,
+  add_path,
+  log_first_parent,
+  show_file,
+  count_merges,
+  merge_count_arguments,
+  is_upstream_not_set_error
+};
+
+export {
+  git_diff_reads,
+  git_command
+};

package/dist/commands/chunk-J4XHEOOW.js

@@ -0,0 +1,156 @@
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-stage-stats.ts
+var DECIMALS = 1;
+var NOT_MEASURED = "not measured";
+var IMPLEMENT = "implement";
+var DRIVER_NOTE = "(driver, outside lane net)";
+var COLUMNS = ["stage", "median (min)", "max (min)", "runs"];
+var { STAGE } = run_ship_stage;
+var STAGES = [
+  IMPLEMENT,
+  STAGE.PREFLIGHT,
+  lane_ledger.PRE_DETACH_STAGE,
+  STAGE.REVIEW,
+  STAGE.SYNC,
+  STAGE.GATE,
+  STAGE.COMMIT,
+  STAGE.ROUND_TWO,
+  STAGE.FOLLOWUP,
+  lane_ledger.CI_WAIT_STAGE,
+  lane_ledger.CODERABBIT_WAIT_STAGE,
+  lane_ledger.CODERABBIT_RATE_LIMIT_STAGE,
+  lane_ledger.CODERABBIT_RETRIGGER_STAGE,
+  STAGE.REPORT
+];
+function is_stage(entry) {
+  return entry.kind === lane_ledger.KIND.STAGE;
+}
+function is_dispatch(entry) {
+  return entry.kind === lane_ledger.KIND.DISPATCH;
+}
+function is_merge(entry) {
+  return entry.kind === lane_ledger.KIND.MERGE;
+}
+function is_number(value) {
+  return value !== void 0;
+}
+function started_ms(stage) {
+  return Date.parse(stage.at) - stage.elapsed_ms;
+}
+function starts_by_issue(stages) {
+  const index = /* @__PURE__ */ new Map();
+  for (const stage of stages) {
+    if (stage.issue === void 0) continue;
+    const starts = index.get(stage.issue) ?? [];
+    starts.push(started_ms(stage));
+    index.set(stage.issue, starts);
+  }
+  return index;
+}
+function next_dispatches_ms(sorted) {
+  const later = /* @__PURE__ */ new Map();
+  return sorted.toReversed().map((dispatch) => {
+    const next_ms = later.get(dispatch.issue) ?? Infinity;
+    later.set(dispatch.issue, Date.parse(dispatch.at));
+    return next_ms;
+  }).toReversed();
+}
+function implement_ms(from_ms, until_ms, starts) {
+  const inside = starts.filter((start) => start >= from_ms && start < until_ms);
+  return inside.length === 0 ? void 0 : Math.min(...inside) - from_ms;
+}
+function implement_spans(entries) {
+  const starts = starts_by_issue(entries.filter(is_stage));
+  const sorted = entries.filter(is_dispatch).toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  const next_ms = next_dispatches_ms(sorted);
+  return sorted.map((dispatch, index) => {
+    const from_ms = Date.parse(dispatch.at);
+    const until_ms = next_ms[index] ?? Infinity;
+    const ms = implement_ms(from_ms, until_ms, starts.get(dispatch.issue) ?? []);
+    return {
+      issue: dispatch.issue,
+      from_ms,
+      to_ms: ms === void 0 ? until_ms : from_ms + ms,
+      is_open: ms === void 0
+    };
+  });
+}
+function implements_of(entries) {
+  return implement_spans(entries).filter((span) => !span.is_open).map(({ issue, from_ms, to_ms }) => ({ issue, ms: to_ms - from_ms }));
+}
+function implement_by_issue(entries) {
+  return new Map(implements_of(entries).map(({ issue, ms }) => [issue, ms]));
+}
+function durations_of(stage, measured) {
+  if (stage === IMPLEMENT) return measured.implement;
+  return measured.stages.filter((entry) => entry.stage === stage).map((entry) => entry.elapsed_ms);
+}
+function cell(milliseconds) {
+  return milliseconds === void 0 ? NOT_MEASURED : (milliseconds / MS_PER_MINUTE).toFixed(DECIMALS);
+}
+function label_of(stage) {
+  return stage === STAGE.FOLLOWUP ? `${stage} ${DRIVER_NOTE}` : stage;
+}
+function stage_row(stage, measured) {
+  const durations = durations_of(stage, measured);
+  return lane_stats.to_row([
+    label_of(stage),
+    cell(lane_stats.median(durations)),
+    cell(lane_stats.peak(durations)),
+    String(durations.length)
+  ]);
+}
+function measured_of(entries) {
+  return {
+    implement: implements_of(entries).map(({ ms }) => ms),
+    stages: entries.filter(is_stage)
+  };
+}
+function table(entries, window) {
+  const measured = measured_of(lane_stats.in_window(entries, window));
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...STAGES.map((stage) => stage_row(stage, measured))
+  ].join("\n");
+}
+function medians(entries) {
+  const measured = measured_of(entries);
+  return new Map(
+    STAGES.flatMap((stage) => {
+      const median = lane_stats.median(durations_of(stage, measured));
+      return median === void 0 ? [] : [[stage, median]];
+    })
+  );
+}
+var lane_stage_stats = {
+  IMPLEMENT,
+  NOT_MEASURED,
+  STAGES,
+  cell,
+  implement_by_issue,
+  implement_spans,
+  is_dispatch,
+  is_merge,
+  is_number,
+  is_stage,
+  medians,
+  started_ms,
+  table
+};
+
+export {
+  lane_stage_stats
+};