@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-Q5Q2QYVU.js

@@ -1,112 +0,0 @@
-import {
-  animation_helpers,
-  create_git_operation_config
-} from "./chunk-GO3GH7FG.js";
-import {
-  BranchMismatchError
-} from "./chunk-KVHNQHX3.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/git/git-branch.ts
-async function current() {
-  const config = {
-    error_message: "Failed to get current branch"
-  };
-  return await animation_helpers.execute_with_animation(
-    "Getting current branch...",
-    git_command.branch,
-    config
-  );
-}
-async function create(branch_name) {
-  const config = create_git_operation_config("Failed to create branch");
-  await animation_helpers.execute_with_animation(
-    `Creating branch: ${branch_name}...`,
-    async () => {
-      await git_command.checkout_b(branch_name);
-      return `Branch created: ${branch_name}`;
-    },
-    config
-  );
-}
-async function switch_to(branch_name) {
-  const config = create_git_operation_config("Failed to switch branch");
-  await animation_helpers.execute_with_animation(
-    `Switching to branch: ${branch_name}...`,
-    async () => {
-      await git_command.checkout(branch_name);
-      return `Switched to branch: ${branch_name}`;
-    },
-    config
-  );
-}
-async function exists(branch_name) {
-  const config = {
-    error_message: "Failed to check branch existence",
-    result_formatter: (is_exists) => is_exists ? "Exists" : "Not found"
-  };
-  return await animation_helpers.execute_with_animation(
-    "Checking if branch exists...",
-    async () => {
-      return await git_command.branch_exists(branch_name);
-    },
-    config
-  );
-}
-async function pull_latest() {
-  const config = create_git_operation_config("Failed to pull latest from remote");
-  await animation_helpers.execute_with_animation(
-    "Pulling latest from remote...",
-    async () => {
-      await git_command.pull_fast_forward();
-      return "Pulled latest from remote";
-    },
-    config
-  );
-}
-var ISSUE_PREFIX_PATTERN = /^(\d+)-/u;
-function has_same_issue_prefix(branch_a, branch_b) {
-  const prefix_a = ISSUE_PREFIX_PATTERN.exec(branch_a)?.[0];
-  const prefix_b = ISSUE_PREFIX_PATTERN.exec(branch_b)?.[0];
-  return prefix_a !== void 0 && prefix_a === prefix_b;
-}
-function issue_from_branch(branch) {
-  const digits = ISSUE_PREFIX_PATTERN.exec(branch)?.[1];
-  return digits === void 0 ? void 0 : Number(digits);
-}
-function is_mismatch(current_branch, target_branch_name, default_branch) {
-  if (current_branch === default_branch || current_branch === target_branch_name) return false;
-  return !has_same_issue_prefix(current_branch, target_branch_name);
-}
-async function handle_default_branch(target_branch_name) {
-  await pull_latest();
-  const is_branch_exists = await exists(target_branch_name);
-  await (is_branch_exists ? switch_to : create)(target_branch_name);
-}
-async function check_and_create_branch(current_branch, target_branch_name) {
-  const default_branch = await git_command.get_default_branch();
-  if (current_branch === default_branch) {
-    await handle_default_branch(target_branch_name);
-    return target_branch_name;
-  }
-  if (is_mismatch(current_branch, target_branch_name, default_branch)) {
-    throw new BranchMismatchError({ current_branch, target_branch_name });
-  }
-  return current_branch;
-}
-var git_branch = {
-  current,
-  check_and_create_branch,
-  is_mismatch,
-  // Exported so a lane's branch name can be checked against the real matcher rather than against a
-  // second copy of the pattern. A copy is what let `lane/<N>` ship: nothing
-  // asserted that the name `lane:open` writes is one this function accepts.
-  has_same_issue_prefix,
-  issue_from_branch
-};
-
-export {
-  git_branch
-};

package/dist/commands/chunk-Q7EEIOAD.js

@@ -1,120 +0,0 @@
-import {
-  git_pr
-} from "./chunk-YDURQICF.js";
-import {
-  live_evidence
-} from "./chunk-3B2HEFNO.js";
-import {
-  git_issue
-} from "./chunk-HI5WPM6C.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/git/git-preflight.ts
-var PRECONDITION = {
-  ISSUE: "issue",
-  BRANCH: "branch",
-  CLASSIFICATION: "classification"
-};
-function unmet(kind, problem) {
-  return { kind, problem };
-}
-function resolve_from_branch(current_branch) {
-  const number = git_issue.branch_number(current_branch);
-  if (number === void 0) {
-    const problem = unmet(PRECONDITION.ISSUE, git_issue.branch_derivation_error(current_branch));
-    return { target: void 0, problems: [problem] };
-  }
-  return { target: { number, branch_name: current_branch }, problems: [] };
-}
-function resolve_parsed(parsed, current_branch, default_branch) {
-  const branch_name = current_branch === default_branch ? parsed.branch_name : current_branch;
-  const target = { number: parsed.number, branch_name };
-  if (!git_branch.is_mismatch(current_branch, parsed.branch_name, default_branch)) {
-    return { target, problems: [] };
-  }
-  return {
-    target,
-    problems: [
-      unmet(
-        PRECONDITION.BRANCH,
-        `Branch mismatch: on "${current_branch}", but the title resolves to "${parsed.branch_name}".`
-      )
-    ]
-  };
-}
-function resolve_from_title(cli_input, current_branch, default_branch) {
-  try {
-    return resolve_parsed(git_issue.parse(cli_input), current_branch, default_branch);
-  } catch (error) {
-    return {
-      target: void 0,
-      problems: [unmet(PRECONDITION.ISSUE, error_text.message_of(error))]
-    };
-  }
-}
-async function resolve_target(cli_input) {
-  const current_branch = await git_branch.current();
-  if (cli_input === void 0) return resolve_from_branch(current_branch);
-  return resolve_from_title(cli_input, current_branch, await git_command.get_default_branch());
-}
-async function classification_problems(target) {
-  try {
-    await git_pr.release_classification(target.number, target.branch_name);
-    return [];
-  } catch (error) {
-    return [unmet(PRECONDITION.CLASSIFICATION, error_text.message_of(error))];
-  }
-}
-async function announce_evidence(branch_name) {
-  const [paths, body] = await Promise.all([
-    changed_paths.read_changed_paths(false),
-    git_gh_command.pr_get_body(branch_name)
-  ]);
-  if (live_evidence.verdict_for(paths, body) !== "required") return;
-  console.info(
-    `\u{1F4A1} This change touches runtime code: the PR body needs a ${live_evidence.EVIDENCE_HEADING} section before \`josh followup\` merges it.`
-  );
-}
-function refusal(problems) {
-  const lines = problems.map(({ problem }) => `  - ${problem}`);
-  return new Error(
-    [
-      `Preflight found ${String(problems.length)} unmet precondition(s); nothing was changed:`,
-      ...lines
-    ].join("\n")
-  );
-}
-async function answer(input) {
-  const { target, problems } = await resolve_target(input.cli_input);
-  const pr_target = input.will_open_pr ? target : void 0;
-  const pr_problems = pr_target === void 0 ? [] : await classification_problems(pr_target);
-  return { pr_target, problems: [...problems, ...pr_problems] };
-}
-async function problems_of(input) {
-  const { problems } = await answer(input);
-  return problems;
-}
-async function check(input) {
-  const { pr_target, problems } = await answer(input);
-  if (problems.length > 0) throw refusal(problems);
-  if (pr_target !== void 0) await announce_evidence(pr_target.branch_name);
-}
-var git_preflight = { check, problems_of };
-
-export {
-  git_preflight
-};

package/dist/commands/chunk-QABRNGQV.js

@@ -1,88 +0,0 @@
-import {
-  issue_run_hold
-} from "./chunk-QX2R6UJG.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  open_issue_schema
-} from "./chunk-34DND4BA.js";
-import {
-  IN_PROGRESS_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  read_json_listing
-} from "./chunk-XDF25GSU.js";
-
-// scripts/epic/epic-busy.ts
-var LISTING_LIMIT = 100;
-var NO_AGES = /* @__PURE__ */ new Map();
-function format_holder(issue, repo, ages) {
-  const cite = session_cite.issue(issue.number, issue.title, repo);
-  const age = ages.get(issue.number);
-  return age === void 0 ? cite : `${cite} (${age})`;
-}
-function format_holders(issues, repo, ages) {
-  return issues.map((issue) => format_holder(issue, repo, ages)).join(", ");
-}
-function occupied_lanes(read) {
-  return read.kind === "busy" ? read.issues.length : 0;
-}
-function occupancy_message(issues, repo, limit, ages = NO_AGES) {
-  return `${String(issues.length)} of ${String(limit)} lanes in use in ${repo}: ${format_holders(issues, repo, ages)}.`;
-}
-function lanes_full_message(issues, repo, limit, ages = NO_AGES) {
-  return `${occupancy_message(issues, repo, limit, ages)} No lane is free, so nothing is offered here. A lane is released when its child merges or is parked; if a label is stale, remove it and ask again, and \`JOSH_LANE_LIMIT\` is what raises the ceiling.`;
-}
-function unreadable_message(repo) {
-  return `Could not read the \`${IN_PROGRESS_LABEL}\` listing for ${repo}. That is not "nothing is running" \u2014 check \`gh auth status\` and ask again.`;
-}
-function truncated_message(repo) {
-  return `\u26A0 The \`${IN_PROGRESS_LABEL}\` listing for ${repo} could not be read to the end, so an issue holding that repository may not be in it. That is not "nothing is running" \u2014 nothing is offered here, and asking again will not clear it. Narrow what carries \`${IN_PROGRESS_LABEL}\` in that repository, or run this child there by hand.`;
-}
-var BUSY_REASONS = {
-  unreadable: unreadable_message,
-  truncated: truncated_message
-};
-function busy_reason(read, repo, limit, ages = NO_AGES) {
-  if (read.kind === "busy") return lanes_full_message(read.issues, repo, limit, ages);
-  if (read.kind === "idle") return "";
-  return BUSY_REASONS[read.kind](repo);
-}
-function is_holder(issue) {
-  return issue_run_hold.is_held((issue.labels ?? []).map((label) => label.name));
-}
-function parse_listing(raw, is_capped) {
-  const read = read_json_listing(raw, open_issue_schema);
-  if (read.kind !== "read") return { kind: "unreadable" };
-  const holders = read.rows.filter((row) => is_holder(row));
-  if (holders.length > 0) return { kind: "busy", issues: holders };
-  return { kind: is_capped ? "truncated" : "idle" };
-}
-async function read_repository(repo) {
-  const { json, is_capped } = await git_gh_command.issue_list_by_label_in_repo(
-    IN_PROGRESS_LABEL,
-    LISTING_LIMIT,
-    repo
-  );
-  return json === void 0 ? { kind: "unreadable" } : parse_listing(json, is_capped);
-}
-var epic_busy = {
-  LISTING_LIMIT,
-  occupied_lanes,
-  occupancy_message,
-  lanes_full_message,
-  unreadable_message,
-  truncated_message,
-  busy_reason,
-  is_holder,
-  parse_listing,
-  read_repository
-};
-
-export {
-  epic_busy
-};

package/dist/commands/chunk-QAHFPCFR.js

@@ -1,50 +0,0 @@
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-
-// scripts/lane/lane-child-mark-keys.ts
-var KEY = "JOSH_LANE_CHILD";
-var OVERRUN_KEY = "JOSH_LANE_OVERRUN";
-var MARK_KEYS = [KEY, OVERRUN_KEY];
-var lane_child_mark_keys = { KEY, MARK_KEYS, OVERRUN_KEY };
-
-// scripts/lane/lane-child-marker.ts
-var { KEY: KEY2, OVERRUN_KEY: OVERRUN_KEY2 } = lane_child_mark_keys;
-var CACHE_TTL_KEY = "CLAUDE_CODE_PROMPT_CACHE_TTL";
-var CACHE_TTL = "5m";
-var OVERRUN_VALUE = "1";
-function environment_for(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return { [KEY2]: issue, [CACHE_TTL_KEY]: CACHE_TTL };
-}
-function marked_issue(source = process.env) {
-  const value = source[KEY2];
-  if (value === void 0) return void 0;
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
-}
-function overrun_environment_for(issue) {
-  return { ...environment_for(issue), [OVERRUN_KEY2]: OVERRUN_VALUE };
-}
-function is_overrun(source = process.env) {
-  return source[OVERRUN_KEY2] === OVERRUN_VALUE && marked_issue(source) !== void 0;
-}
-function is_child_of(directory, source = process.env) {
-  const marked = marked_issue(source);
-  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
-}
-var lane_child_marker = {
-  KEY: KEY2,
-  OVERRUN_KEY: OVERRUN_KEY2,
-  env_for: environment_for,
-  overrun_env_for: overrun_environment_for,
-  is_child_of,
-  is_overrun,
-  marked_issue
-};
-
-export {
-  lane_child_marker
-};

package/dist/commands/chunk-QDFVVRQP.js

@@ -1,92 +0,0 @@
-import {
-  issue_closing_pr
-} from "./chunk-KZSM5M5P.js";
-import {
-  issue_sample_gate
-} from "./chunk-CQUZ6TNQ.js";
-import {
-  git_closes_keyword
-} from "./chunk-J3TKZLHA.js";
-import {
-  git_gh_pr_too_large,
-  read_pull
-} from "./chunk-23GH6B3D.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  git_gh_issue_rest
-} from "./chunk-ENKFCOVY.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-
-// scripts/issue/issue-sample-prime.ts
-async function read_as_issue(pr) {
-  const json = await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(String(pr)) });
-  const issue = git_gh_issue_rest.parse_rest_issue(json);
-  return { body: issue.body, merged_at: issue.pull_request?.merged_at };
-}
-async function read_fields(pr) {
-  try {
-    return await read_pull(pr);
-  } catch (error) {
-    if (!git_gh_pr_too_large.is_too_many_files(error)) throw error;
-    return await read_as_issue(pr);
-  }
-}
-async function read_source(pr) {
-  const pull = await read_fields(pr);
-  const closes = git_closes_keyword.parse_closes_issue_number(pull.body ?? void 0);
-  return {
-    merged_at: pull.merged_at ?? void 0,
-    closes: closes === void 0 ? void 0 : Number(closes)
-  };
-}
-async function read_closing_source(issue) {
-  const pr = await issue_closing_pr.read_closing_number(issue);
-  if (pr === void 0) return { merged_at: void 0, closes: issue };
-  const { merged_at } = await read_source(pr);
-  return { merged_at, closes: issue };
-}
-var DEFAULT_PORTS = {
-  pull: read_source,
-  closing: read_closing_source,
-  ledger_path: lane_ledger.target
-};
-function merges_of(path) {
-  return function merges() {
-    if (path === void 0) return [];
-    return lane_ledger.read_entries(path).filter((entry) => entry.kind === lane_ledger.KIND.MERGE);
-  };
-}
-async function remember(condition, ports) {
-  const read = condition.via === "pull" ? ports.pull : ports.closing;
-  try {
-    issue_sample_gate.record(condition, await read(condition.cited));
-  } catch {
-    issue_sample_gate.record(condition, void 0);
-  }
-}
-async function prime(bodies, ports = DEFAULT_PORTS) {
-  const unread = issue_sample_gate.unread_of(bodies);
-  if (unread.length === 0) return;
-  issue_sample_gate.use_merges(merges_of(await ports.ledger_path()));
-  await Promise.all(
-    unread.map(async (condition) => {
-      await remember(condition, ports);
-    })
-  );
-}
-var issue_sample_prime = {
-  prime,
-  read_closing: read_closing_source,
-  read_source
-};
-
-export {
-  issue_sample_prime
-};

package/dist/commands/chunk-QGAERR7D.js

@@ -1,99 +0,0 @@
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  atomic_write
-} from "./chunk-KSR23NYN.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/rules/rule-value-cache.ts
-import { spawn } from "node:child_process";
-import { statSync } from "node:fs";
-import path from "node:path";
-var FALLBACK_DIRECTORY = ["node_modules", ".cache", "josh"];
-var CACHE_FILE = "rule-value.txt";
-var STAMP_FILE = "rule-value.stamp";
-var REFRESH_MINUTES = 15;
-var REFRESH_MS = REFRESH_MINUTES * MS_PER_MINUTE;
-var REFRESH_ARGV = ["josh", "rule:value", "--refresh"];
-var PNPM = "pnpm";
-function cache_path(cwd, file) {
-  const common = git_common_directory.repository(cwd);
-  if (common === void 0) return path.join(cwd, ...FALLBACK_DIRECTORY, file);
-  return path.join(common, git_common_directory.STATE_DIRECTORY, file);
-}
-function read_cached(cwd) {
-  return file_reader.read_if_readable(cache_path(cwd, CACHE_FILE));
-}
-function taken_at_if_fresh(cwd, now_ms) {
-  try {
-    const { mtime } = statSync(cache_path(cwd, CACHE_FILE));
-    return now_ms - mtime.getTime() < REFRESH_MS ? mtime : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function read_fresh(cwd = process.cwd(), now_ms = Date.now()) {
-  const taken_at = taken_at_if_fresh(cwd, now_ms);
-  if (taken_at === void 0) return void 0;
-  const text = read_cached(cwd);
-  return text === void 0 ? void 0 : { text, taken_at };
-}
-function is_refresh_due(cwd, now_ms) {
-  try {
-    return now_ms - statSync(cache_path(cwd, STAMP_FILE)).mtimeMs >= REFRESH_MS;
-  } catch {
-    return true;
-  }
-}
-function write_cache_file(cwd, file, text) {
-  atomic_write.replace_file(cache_path(cwd, file), text);
-}
-function ignore_spawn_error() {
-}
-function start_refresh_default(cwd) {
-  const child = spawn(PNPM, REFRESH_ARGV, { cwd, detached: true, stdio: "ignore" });
-  child.on("error", ignore_spawn_error);
-  child.unref();
-}
-var DEFAULT_PORTS = { now: Date.now, start_refresh: start_refresh_default };
-function is_linked_work_tree(cwd) {
-  return git_common_directory.resolve(cwd) !== void 0;
-}
-function refresh_if_due(cwd, ports) {
-  if (is_linked_work_tree(cwd) || !is_refresh_due(cwd, ports.now())) return;
-  write_cache_file(cwd, STAMP_FILE, new Date(ports.now()).toISOString());
-  ports.start_refresh(cwd);
-}
-function emit(cwd = process.cwd(), ports = DEFAULT_PORTS) {
-  const cached = read_cached(cwd);
-  if (cached !== void 0) process.stderr.write(cached);
-  try {
-    refresh_if_due(cwd, ports);
-  } catch {
-  }
-}
-function store(text, cwd = process.cwd()) {
-  if (is_linked_work_tree(cwd)) return;
-  write_cache_file(cwd, CACHE_FILE, `${text}
-`);
-}
-var rule_value_cache = {
-  CACHE_FILE,
-  REFRESH_MS,
-  STAMP_FILE,
-  cache_path,
-  emit,
-  is_linked_work_tree,
-  read_fresh,
-  store
-};
-
-export {
-  rule_value_cache
-};

package/dist/commands/chunk-QHWJJ6X5.js

@@ -1,53 +0,0 @@
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-
-// scripts/josh/path-decision.ts
-var STAGED_FLAG = "--staged";
-var JSON_FLAG = "--json";
-var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
-var FAILURE_EXIT_CODE = 1;
-var MAX_LISTED_PATHS = 5;
-function has_unknown_flag(argv, known) {
-  return argv.some((argument) => !known.includes(argument));
-}
-function parse_options(argv) {
-  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
-  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
-}
-function format_path_list(paths) {
-  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
-  if (paths.length <= MAX_LISTED_PATHS) return listed;
-  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
-}
-function print_decision(key, answer, reason, is_json) {
-  if (is_json) {
-    console.info(JSON.stringify({ [key]: answer, reason }));
-    return;
-  }
-  console.info(answer);
-  console.error(reason);
-}
-async function run_path_decision(argv, command) {
-  const options = parse_options(argv);
-  if (options === void 0) {
-    console.error(command.usage);
-    return FAILURE_EXIT_CODE;
-  }
-  const paths = await changed_paths.read_changed_paths(options.is_staged);
-  const answer = await command.decide(paths, options.is_staged);
-  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
-  return 0;
-}
-var path_decision = {
-  format_path_list,
-  has_unknown_flag,
-  JSON_FLAG,
-  parse_options,
-  print_decision,
-  run_path_decision
-};
-
-export {
-  path_decision
-};