@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-ACZ52JPI.js

@@ -1,140 +0,0 @@
-import {
-  lane_breakdown_laps
-} from "./chunk-QMDKDQKW.js";
-import {
-  lane_breakdown
-} from "./chunk-MLW4S35K.js";
-import {
-  lane_net_time
-} from "./chunk-MWO6FOSZ.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  MAX_SCANNED,
-  git_gh_issue_list
-} from "./chunk-HXDTA5VU.js";
-import {
-  run_ship_lap
-} from "./chunk-PE7B7242.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lane/lane-sinks-issues.ts
-import { z } from "zod";
-var NONE = "none";
-var UNREAD = "unread";
-var SEPARATOR = ", ";
-var open_issues_schema = z.array(z.object({ number: z.number(), title: z.string() }));
-async function read() {
-  const outcome = await git_gh_issue_list.issue_list({
-    json_fields: "number,title",
-    limit: MAX_SCANNED
-  });
-  return outcome.json === void 0 ? void 0 : json_value.parse_with(outcome.json, open_issues_schema);
-}
-function cell(stage, issues, also = []) {
-  if (issues === void 0) return UNREAD;
-  const needles = [stage, ...also].map((name) => name.toLowerCase());
-  const named = issues.filter(
-    (issue) => needles.some((needle) => issue.title.toLowerCase().includes(needle))
-  );
-  return named.length === 0 ? NONE : named.map((issue) => issue_cite.plain_for("linked", issue.number)).join(SEPARATOR);
-}
-var lane_sinks_issues = { NONE, UNREAD, read, cell };
-
-// scripts/lane/lane-sinks.ts
-import path from "node:path";
-var DEFAULT_MINUTES = 30;
-var NOTE_LEAD = " (";
-var COLUMNS = ["stage", "total min", "lanes", "median min", "open issues"];
-var { SCOPED_PAIR } = run_ship_lap.STEP;
-function over_issues(records, window, minutes) {
-  const merged = lane_stats.in_window(records.entries, window).filter((entry) => lane_stage_stats.is_merge(entry)).map((merge) => merge.issue);
-  return [...new Set(merged)].filter(
-    (issue) => (lane_net_time.net_ms(records.entries, records.events, issue) ?? 0) > minutes * MS_PER_MINUTE
-  );
-}
-function base_name(name) {
-  const note_at = name.indexOf(NOTE_LEAD);
-  return note_at === -1 ? name : name.slice(0, note_at);
-}
-function lane_parts(records, issue) {
-  const breakdown = lane_breakdown.of(records.entries, records.events, issue);
-  if (breakdown === void 0) return [];
-  const laps = lane_breakdown_laps.of(records.entries, issue, breakdown, []);
-  const parts = [
-    ...breakdown.stages,
-    ...breakdown.stages.flatMap((stage) => laps.get(stage.name) ?? [])
-  ];
-  return lane_breakdown.ranked(parts.map((part) => ({ name: base_name(part.name), ms: part.ms })));
-}
-function total_ms(sink) {
-  return sink.per_lane_ms.reduce((sum, ms) => sum + ms, 0);
-}
-function sinks_of(records, issues) {
-  const sinks = /* @__PURE__ */ new Map();
-  for (const issue of issues) {
-    for (const { name, ms } of lane_parts(records, issue)) {
-      sinks.set(name, [...sinks.get(name) ?? [], ms]);
-    }
-  }
-  return [...sinks].map(([name, per_lane_ms]) => ({ name, per_lane_ms })).toSorted((left, right) => total_ms(right) - total_ms(left));
-}
-function is_test_related(entry) {
-  return entry.kind === lane_ledger.KIND.TEST_RELATED;
-}
-function hubs_of(entries, issues) {
-  const named = entries.filter((entry) => is_test_related(entry)).filter((entry) => entry.issue !== void 0 && issues.includes(entry.issue)).map((entry) => entry.over_cap_hub).filter((hub) => hub !== void 0);
-  return [...new Set(named)];
-}
-function issues_cell(name, issues, hubs) {
-  const also = name === SCOPED_PAIR ? hubs.map((hub) => path.basename(hub)) : [];
-  return lane_sinks_issues.cell(name, issues, also);
-}
-function sink_row(sink, issues, hubs) {
-  return lane_stats.to_row([
-    sink.name,
-    lane_stage_stats.cell(total_ms(sink)),
-    String(sink.per_lane_ms.length),
-    lane_stage_stats.cell(lane_stats.median(sink.per_lane_ms)),
-    issues_cell(sink.name, issues, hubs)
-  ]);
-}
-function table(records, window, minutes, issues) {
-  const lanes = over_issues(records, window, minutes);
-  const hubs = hubs_of(records.entries, lanes);
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    ...sinks_of(records, lanes).map((sink) => sink_row(sink, issues, hubs))
-  ].join("\n");
-}
-var lane_sinks = {
-  DEFAULT_MINUTES,
-  base_name,
-  hubs_of,
-  issues_cell,
-  over_issues,
-  sinks_of,
-  table,
-  total_ms
-};
-
-export {
-  lane_sinks_issues,
-  lane_sinks
-};

package/dist/commands/chunk-AJ65WNJB.js

@@ -1,230 +0,0 @@
-import {
-  git_gh_pr_read
-} from "./chunk-23GH6B3D.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/run-preflight.ts
-import { z } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-var OPEN_PR = "open";
-var MERGED_PR = "merged";
-var CLOSED_PR = "closed";
-var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z.object({ state: z.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue) {
-  if (!tree.is_dirty) return [];
-  return [
-    `pnpm josh stash:push "${STASH_LABEL_PREFIX}${issue}"`,
-    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue) {
-  return [
-    ...reclaim_steps(tree, issue),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice(verdict, issue, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide(tree, child, issue) {
-  const verdict = to_verdict(tree, child);
-  return {
-    advice: to_advice(verdict, issue, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function has_stashable_work() {
-  try {
-    return await git_stash.has_stashable_changes();
-  } catch (error) {
-    error_text.trace_swallowed("run_preflight.has_stashable_work", error);
-    return true;
-  }
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    has_stashable_work(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read) => is_pr_decided(read.pr_state));
-  const open = reads.find((read) => is_pr_open(read.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
-  return groups;
-}
-async function read_branch_candidates(issue) {
-  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference) => [to_head_branch(reference), reference])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue) {
-  const candidates = await read_branch_candidates(issue);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read) => read !== void 0));
-}
-async function check(issue) {
-  require_issue_number(issue);
-  const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide(tree, NO_CHILD_WORK, issue);
-  return decide(tree, await read_child_state(issue), issue);
-}
-var run_preflight = {
-  CLEAN_VERDICT,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check,
-  decide,
-  read_child_state,
-  read_pr_state,
-  to_pr_state
-};
-
-export {
-  run_preflight
-};

package/dist/commands/chunk-AK7SEO4Y.js

@@ -1,177 +0,0 @@
-import {
-  confirmation_options,
-  telegram_notify
-} from "./chunk-WJ4NEDNI.js";
-import {
-  github_issue_url
-} from "./chunk-S4X5PJV7.js";
-import {
-  cli_body
-} from "./chunk-7IZJ5MG2.js";
-import {
-  git_gh_repo
-} from "./chunk-GJYMI2CM.js";
-import {
-  git_error
-} from "./chunk-KVHNQHX3.js";
-import {
-  josh_environment_file
-} from "./chunk-NFKULY26.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-
-// scripts/notify/telegram-test-logic.ts
-var VALID_TASK_TYPES = [
-  "planning",
-  "completion",
-  "failure",
-  "warning",
-  "kickoff_retry",
-  "confirmation"
-];
-var DEFAULT_TASK_TYPE = "planning";
-function parse_task_type(raw) {
-  if (raw === void 0) return DEFAULT_TASK_TYPE;
-  const matched = VALID_TASK_TYPES.find((candidate) => candidate === raw);
-  if (matched === void 0) {
-    throw new Error(`Invalid --task-type: ${raw}. Expected one of ${VALID_TASK_TYPES.join(", ")}.`);
-  }
-  return matched;
-}
-var has_flag_value = cli_body.has_value;
-function coalesce(primary, fallback) {
-  if (has_flag_value(primary)) return primary;
-  return fallback;
-}
-function normalize_body(values) {
-  return cli_body.resolve({
-    inline: values.body,
-    file_path: values["body-file"],
-    inline_flag: "--body",
-    file_flag: "--body-file"
-  });
-}
-function require_recommended(values) {
-  const recommended = values.recommended?.trim() ?? "";
-  if (recommended.length === 0) {
-    throw new Error('--task-type confirmation needs --recommended "<the recommended choice>".');
-  }
-  return recommended;
-}
-function given_alternatives(values) {
-  return (values.alternative ?? []).filter((alternative) => alternative.trim().length > 0);
-}
-function build_choices(values, task_type) {
-  if (task_type !== "confirmation") return void 0;
-  return confirmation_options.block({
-    recommended: require_recommended(values),
-    alternatives: given_alternatives(values)
-  });
-}
-function build_input(input) {
-  const task_type = parse_task_type(input.values["task-type"]);
-  return {
-    task_type,
-    repo_name: coalesce(input.values["repo-name"], input.context.repo_name),
-    issue_title: coalesce(input.values["issue-title"], input.context.issue_title),
-    body: normalize_body(input.values),
-    choices: build_choices(input.values, task_type),
-    issue_url: input.values["issue-url"],
-    pr_url: input.values["pr-url"]
-  };
-}
-var telegram_test_logic = {
-  build_input,
-  parse_task_type,
-  has_flag_value
-};
-
-// scripts/notify/telegram-test.ts
-var REPO_NAME_SEPARATOR = "/";
-var ARGV_OFFSET = 2;
-var FAILURE_EXIT_CODE = 1;
-var USAGE = "Usage: josh notify [--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...";
-var FREE_TEXT_FLAGS = ["--body", "--issue-title", "--recommended", "--alternative"];
-var OPTIONS = {
-  "task-type": { type: "string" },
-  "repo-name": { type: "string" },
-  "issue-title": { type: "string" },
-  body: { type: "string" },
-  "body-file": { type: "string" },
-  "issue-url": { type: "string" },
-  "pr-url": { type: "string" },
-  recommended: { type: "string" },
-  alternative: { type: "string", multiple: true }
-};
-function parse_cli_arguments() {
-  return cli_flags.values_of(
-    cli_flags.attach_values(process.argv.slice(ARGV_OFFSET), FREE_TEXT_FLAGS),
-    OPTIONS
-  );
-}
-function refuse_usage() {
-  console.error(USAGE);
-  process.exitCode = FAILURE_EXIT_CODE;
-}
-async function fetch_repo_name() {
-  try {
-    const name_with_owner = await git_gh_repo.repo_get_name_with_owner();
-    return name_with_owner?.split(REPO_NAME_SEPARATOR).at(-1);
-  } catch (error) {
-    console.warn(`\u26A0\uFE0F  Could not read the repository name, sending without it: ${String(error)}`);
-    return void 0;
-  }
-}
-async function fetch_issue_title(target) {
-  if (target === void 0) return void 0;
-  const title = await git_gh_issue_read.issue_get_title(target.issue_number, target.name_with_owner);
-  if (title === void 0) {
-    console.warn(
-      `\u26A0\uFE0F  Could not read ${session_cite.issue(target.issue_number, void 0, target.name_with_owner)}.`
-    );
-  }
-  return title;
-}
-async function resolve_issue_title(values, target) {
-  if (telegram_test_logic.has_flag_value(values["issue-title"])) return void 0;
-  return await fetch_issue_title(target);
-}
-async function resolve_context(values) {
-  const target = github_issue_url.parse(values["issue-url"]);
-  const pull_target = github_issue_url.parse_pull(values["pr-url"]);
-  const repo_name = target?.repo ?? pull_target?.repo ?? await fetch_repo_name();
-  const issue_title = await resolve_issue_title(values, target);
-  return { repo_name, issue_title };
-}
-async function send_values(values) {
-  const context = await resolve_context(values);
-  await telegram_notify.send(telegram_test_logic.build_input({ values, context }));
-}
-async function main() {
-  josh_environment_file.load_environment_file();
-  const values = parse_cli_arguments();
-  if (values === void 0) {
-    refuse_usage();
-    return;
-  }
-  await send_values(values);
-}
-async function run_cli() {
-  try {
-    await main();
-  } catch (error) {
-    git_error.handle(error);
-  }
-}
-var telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli, send_values };
-
-export {
-  telegram_test
-};