@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-2QM72JCJ.js

@@ -1,338 +0,0 @@
-import {
-  split_resolution
-} from "./chunk-RUQY5TS3.js";
-import {
-  auto_ok_cli
-} from "./chunk-FMZWRDKH.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  lane_implement_rate_read
-} from "./chunk-FURNDIT3.js";
-import {
-  declared_growth,
-  split_assess
-} from "./chunk-D7JRJI44.js";
-import {
-  lane_stage_budget
-} from "./chunk-AXXEMVRJ.js";
-import {
-  lane_implement_rate,
-  lane_size_stats
-} from "./chunk-D6D6WQR6.js";
-import {
-  run_ship_planned
-} from "./chunk-TAEGXID2.js";
-import {
-  backlog_overlap,
-  lane_plan,
-  lane_plan_approval
-} from "./chunk-B7ZNIEDV.js";
-import {
-  test_related_cap
-} from "./chunk-NEGRE5VW.js";
-import {
-  test_pinned_logic
-} from "./chunk-Y27PTXXI.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  IN_PROGRESS_LABEL,
-  has_any_label
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/lane/lane-plan-size.ts
-function declared_of(issue, issues) {
-  const body = issues.find((candidate) => candidate.number === issue)?.body;
-  const size = body === void 0 ? void 0 : size_estimate.declared_size(body);
-  return size === void 0 || size.files === 0 ? void 0 : size;
-}
-function declares(issue, issues) {
-  return declared_of(issue, issues) !== void 0;
-}
-function ratios_of(signals) {
-  return { files: signals.files_ratio, lines: signals.lines_ratio };
-}
-function guide_of(signals) {
-  return split_assess.guide_for(
-    lane_stage_budget.BUDGET_MINUTES.implement,
-    signals.implement_rate,
-    ratios_of(signals)
-  );
-}
-function ordered(counted, recorded) {
-  const held = new Set(recorded);
-  return [...counted.filter((file) => held.has(file)), ...counted.filter((file) => !held.has(file))];
-}
-function units_of(files, signals) {
-  const base = signals.base_files ?? new Set(files);
-  return split_assess.units_of(files, new Set(files.filter((file) => !base.has(file))));
-}
-function files_approved(plan, declared, recorded, measured) {
-  const approval = plan.size_approval ?? recorded?.size_approval;
-  return approval !== void 0 && lane_plan_approval.allows(approval, plan, { reason: "files", declared, measured });
-}
-function is_counted(file) {
-  return split_assess.is_deliverable({ path: file, changed_lines: 0 });
-}
-function files_over(plan, declared, recorded, signals) {
-  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
-  const counted = plan.paths.filter((file) => is_counted(file));
-  const units = units_of(ordered(counted, recorded?.paths ?? []), signals);
-  if (units.length <= limit || files_approved(plan, declared, recorded, units.length)) {
-    return void 0;
-  }
-  const tests = plan.paths.filter((file) => test_declared_logic.is_test_file(file));
-  const kept = counted.filter((file) => units.slice(0, limit).flat().includes(file));
-  const split_off = counted.filter((file) => units.slice(limit).flat().includes(file));
-  return { reason: "files", declared, limit, kept, split_off, tests };
-}
-function earlier_cleared(recorded, signals) {
-  if (recorded?.cleared_paths !== void 0) return recorded.cleared_paths;
-  return recorded?.cleared === true ? signals.committed_files : [];
-}
-function unplanned_hunks(signals, plan, recorded) {
-  const listed = plan.paths.filter((path) => !path.endsWith("/"));
-  const planned = [...listed, ...recorded?.paths ?? [], ...earlier_cleared(recorded, signals)];
-  return run_ship_planned.unplanned_of(planned, signals.hunk_files).length;
-}
-function hunks_over(declared, hunks, signals) {
-  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
-  return hunks > limit ? { reason: "hunks", declared, limit, measured: hunks } : void 0;
-}
-function lines_limit(signals) {
-  const growth = ratios_of(signals);
-  const bar = size_estimate.declared_lines_bar(signals.implement_rate, growth);
-  return bar ?? Math.floor(guide_of(signals).lines / declared_growth.factor(growth, "lines"));
-}
-function lines_over(declared, signals) {
-  const limit = lines_limit(signals);
-  if (declared <= limit) return void 0;
-  const measured = Math.round(declared * declared_growth.factor(ratios_of(signals), "lines"));
-  return { reason: "lines", declared, limit, measured };
-}
-function unapproved(over, plan, approval) {
-  if (over === void 0 || approval === void 0) return over;
-  if (over.reason !== "lines") return over;
-  const is_within = lane_plan_approval.allows(approval, plan, { ...over, reason: over.reason });
-  return is_within ? void 0 : over;
-}
-function planned_lines(declared, signals, plan, recorded) {
-  const approval = plan.size_approval ?? recorded?.size_approval;
-  if (approval === void 0 && lane_plan.is_sized(recorded)) return void 0;
-  return unapproved(lines_over(declared, signals), plan, approval);
-}
-function measure_over(declared, signals, plan, recorded) {
-  if (signals.split_filed) return void 0;
-  const estimated = Math.max(declared.lines, plan.estimated_size?.lines ?? 0);
-  return hunks_over(declared.files, unplanned_hunks(signals, plan, recorded), signals) ?? planned_lines(estimated, signals, plan, recorded);
-}
-function is_waived(plan, over) {
-  return over !== void 0 && (plan.single === true || plan.sized === true);
-}
-function hub_over(signals) {
-  const hubs = signals.hubs ?? [];
-  return hubs.length === 0 ? void 0 : { reason: "hub", limit: test_pinned_logic.MAX_TEST_FILES, hubs };
-}
-function first_over(plan, declared, recorded, signals) {
-  const files = files_over(plan, declared.files, recorded, signals);
-  if (files !== void 0 && !is_waived(plan, files)) return files;
-  return hub_over(signals) ?? measure_over(declared, signals, plan, recorded) ?? files;
-}
-function oversize(plan, issues, recorded, signals) {
-  const declared = declared_of(plan.issue, issues);
-  if (declared === void 0) return void 0;
-  const over = first_over(plan, declared, recorded, signals);
-  return over === void 0 ? void 0 : { ...over, guide: guide_of(signals) };
-}
-function bar_tail() {
-  return `A \`${split_assess.REASON_PREFIX}\` comment does not pass this bar \u2014 split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}".`;
-}
-var SIZE_PREFIX = issue_body_keys.prefix("size");
-function files_text(issue, over) {
-  const planned = [...over.kept, ...over.split_off];
-  const counted = split_assess.units_of(planned, /* @__PURE__ */ new Set()).length;
-  const bar = `${String(counted)} files (tests and generated artifacts excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} its \`${SIZE_PREFIX}\` declares`;
-  const replan = ["pnpm josh lane:plan", String(issue), ...over.kept, ...over.tests].join(" ");
-  return `split (files): ${session_cite.issue(issue)}'s plan holds ${bar}, so it is not recorded. Keep in this Issue: ${over.kept.join(", ")}. Split off: ${over.split_off.join(", ")} \u2014 file them as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to them here, run \`${replan}\`, and ship this Issue on the kept files. One deliverable with no separately-mergeable part instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
-}
-function waiver_text(issue, over) {
-  return `size warning (${over.reason}): ${session_cite.issue(issue)}'s plan is past its ${String(over.limit)} bar, recorded and noted on the ledger \u2014 a warning, not a stop; finish this Issue, never split it \u2014 an overrun at the merge is recorded as a pre-split miss (split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}").`;
-}
-function measure_bar(over) {
-  if (over.reason === "hunks") {
-    return `change holds ${String(over.measured)} hunks outside the plan's files (tests excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} files its \`${SIZE_PREFIX}\` declares`;
-  }
-  return `\`${SIZE_PREFIX}\` declares ${String(over.declared)} lines, about ${String(over.measured)} at the lines lanes ran over their declaration \u2014 over the ${String(over.limit)} declared lines the size bar allows`;
-}
-function measure_text(issue, over) {
-  return `split (${over.reason}): ${session_cite.issue(issue)}'s ${measure_bar(over)}, so the plan is not recorded. Carve a separately-mergeable part off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. ${bar_tail()}`;
-}
-function hub_text(issue, over) {
-  return `split (hub): ${session_cite.issue(issue)}'s plan edits ${over.hubs.join(", ")}, whose \`test:related\` reach passes the ${String(over.limit)}-test-file cap, so the plan is not recorded. Carve the hub edit off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. The hub edit is the one deliverable instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
-}
-function over_text(issue, over) {
-  if (over.reason === "files") return files_text(issue, over);
-  return over.reason === "hub" ? hub_text(issue, over) : measure_text(issue, over);
-}
-function refusal_text(issue, over) {
-  const text = over_text(issue, over);
-  const guide = over.guide ?? split_assess.guide_for(lane_stage_budget.BUDGET_MINUTES.implement);
-  return `${text} ${split_assess.policy_text(guide)}`;
-}
-var lane_plan_size = { declares, is_waived, oversize, refusal_text, waiver_text };
-
-// scripts/lane/lane-plan-signals.ts
-var RATIO_PERIOD_DAYS = lane_implement_rate_read.PERIOD_DAYS;
-var NAME_ONLY = "--name-only";
-var DIFF_ARGUMENTS = [
-  "diff",
-  "-U0",
-  "--no-color",
-  "--no-ext-diff",
-  "--diff-filter=M",
-  "--src-prefix=a/",
-  "--dst-prefix=b/"
-];
-function hunk_files(diff) {
-  return test_pinned_logic.parse_hunks(diff).map((hunk) => hunk.file);
-}
-var NO_PROBE = { hunk_files: [], committed_files: [] };
-async function read_or_empty(arguments_) {
-  try {
-    return await git_spawn.read(arguments_);
-  } catch {
-    return "";
-  }
-}
-function names_of(output) {
-  return output.split("\n").filter((name) => name !== "");
-}
-async function base_files_of(base) {
-  try {
-    return new Set(names_of(await git_spawn.read(["ls-tree", "-r", NAME_ONLY, base])));
-  } catch {
-    return void 0;
-  }
-}
-async function probe_of(base) {
-  const [diff, committed, base_files] = await Promise.all([
-    read_or_empty([...DIFF_ARGUMENTS, base]),
-    read_or_empty(["diff", NAME_ONLY, `${base}...HEAD`]),
-    base_files_of(base)
-  ]);
-  return { hunk_files: hunk_files(diff), committed_files: names_of(committed), base_files };
-}
-async function tree_of() {
-  const base = await change_base.resolved_through_merge();
-  return base === void 0 ? NO_PROBE : await probe_of(base);
-}
-async function entries_of() {
-  const ledger = await lane_ledger.target();
-  return ledger === void 0 ? [] : lane_ledger.read_entries(ledger);
-}
-function signals_from(issue, tree, entries, now_ms) {
-  const window = lane_stats.window_of(RATIO_PERIOD_DAYS, now_ms);
-  const ratios = lane_size_stats.ratios(entries, window);
-  return {
-    ...tree,
-    files_ratio: ratios.files,
-    lines_ratio: ratios.lines,
-    implement_rate: lane_implement_rate.rate(entries, window),
-    split_filed: split_resolution.split_issues(entries).has(issue)
-  };
-}
-async function hubs_of(paths) {
-  return paths.length === 0 ? [] : await test_related_cap.hubs_of(process.cwd(), paths);
-}
-async function signals_of(issue, paths = []) {
-  const [tree, entries, hubs] = await Promise.all([tree_of(), entries_of(), hubs_of(paths)]);
-  return { ...signals_from(issue, tree, entries, Date.now()), hubs };
-}
-var lane_plan_signals = { hunk_files, signals_from, signals_of };
-
-// scripts/lane/lane-plan-probe.ts
-var RUNNING = /* @__PURE__ */ new Set([IN_PROGRESS_LABEL]);
-var UNREAD = "unread";
-var OVERSIZE = "oversize";
-async function opted_in() {
-  const read = await auto_ok_cli.fetch_opted_in();
-  return read.kind === "read" ? read.issues : void 0;
-}
-function running_of(issues) {
-  return issues.filter((issue) => has_any_label(issue.labels, RUNNING));
-}
-function clash_among(plan, issues, directory) {
-  const declared = lane_plan.with_plans(backlog_overlap.declared_of(issues), directory);
-  return lane_plan.clash_of(plan, declared, directory);
-}
-function overlap_text(issue, clash) {
-  const holder = session_cite.issue(clash.holder);
-  return `${session_cite.issue(issue)}'s planned \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares or plans`;
-}
-function probe(plan, issues, directory) {
-  return issues === void 0 ? UNREAD : clash_among(plan, running_of(issues), directory);
-}
-function is_unread(found) {
-  return found === UNREAD;
-}
-function record_cleared(plan, directory) {
-  lane_plan.record(
-    { ...plan, cleared: true, yielded: void 0, waits_until: void 0 },
-    directory
-  );
-}
-async function oversize_of(plan, issues, directory) {
-  if (issues === void 0 || !lane_plan_size.declares(plan.issue, issues)) return void 0;
-  const signals = await lane_plan_signals.signals_of(plan.issue, plan.paths);
-  return lane_plan_size.oversize(plan, issues, lane_plan.read(plan.issue, directory), signals);
-}
-function is_oversize(found) {
-  return found === OVERSIZE;
-}
-async function extend(plan, directory) {
-  const issues = await opted_in();
-  const over = await oversize_of(plan, issues, directory);
-  if (over !== void 0 && !lane_plan_size.is_waived(plan, over)) return OVERSIZE;
-  const found = probe(plan, issues, directory);
-  if (found === void 0) record_cleared(plan, directory);
-  return found;
-}
-var lane_plan_probe = {
-  clash_among,
-  extend,
-  is_oversize,
-  is_unread,
-  opted_in,
-  overlap_text,
-  oversize_of,
-  probe,
-  record_cleared,
-  running_of
-};
-
-export {
-  lane_plan_signals,
-  lane_plan_size,
-  lane_plan_probe
-};

package/dist/commands/chunk-2VRITY55.js

@@ -1,41 +0,0 @@
-// scripts/josh/josh-run.ts
-import { execa } from "execa";
-var PNPM = "pnpm";
-var JOSH = "josh";
-var SUCCESS_EXIT_CODE = 0;
-var NONZERO_EXIT = 1;
-var FORWARDED_STDERR = ["pipe", "inherit"];
-function extra_options(timeout_ms, environment) {
-  return {
-    ...timeout_ms !== void 0 && { timeout: timeout_ms },
-    ...environment !== void 0 && { env: environment }
-  };
-}
-async function run_with_options(args, should_forward_stderr, options) {
-  const result = await execa(PNPM, [JOSH, ...args], {
-    reject: false,
-    stderr: should_forward_stderr ? FORWARDED_STDERR : "pipe",
-    ...options
-  });
-  return {
-    code: result.exitCode ?? NONZERO_EXIT,
-    out: result.stdout.trim(),
-    err: result.stderr.trim()
-  };
-}
-async function josh_run(args, should_forward_stderr = false, timeout_ms, environment) {
-  return await run_with_options(args, should_forward_stderr, extra_options(timeout_ms, environment));
-}
-async function josh_run_at(args, cwd) {
-  return await run_with_options(args, false, { cwd });
-}
-function require_success(result, command) {
-  if (result.code === SUCCESS_EXIT_CODE) return;
-  const reason = [result.err, result.out].find((text) => text?.trim());
-  throw new Error(reason ?? `${command} exited ${String(result.code)}`);
-}
-var josh_command = { josh_run, josh_run_at, require_success };
-
-export {
-  josh_command
-};

package/dist/commands/chunk-2XAH3MHV.js

@@ -1,23 +0,0 @@
-import {
-  split_assess
-} from "./chunk-D7JRJI44.js";
-
-// scripts/issue/issue-fold.ts
-var FOLD = "fold";
-var SEPARATE = "separate";
-var NO_FOLD_NEEDED = "no-fold-needed";
-var UNDETERMINED = "undetermined";
-var MIN_CANDIDATES = 2;
-function separable_verdict(size_verdict) {
-  if (size_verdict === void 0) return UNDETERMINED;
-  return size_verdict === split_assess.SPLIT_VERDICT ? SEPARATE : FOLD;
-}
-function fold_verdict(candidate_count, is_separable, size_verdict) {
-  if (candidate_count < MIN_CANDIDATES) return NO_FOLD_NEEDED;
-  return is_separable ? separable_verdict(size_verdict) : FOLD;
-}
-var issue_fold = { FOLD, SEPARATE, NO_FOLD_NEEDED, UNDETERMINED, MIN_CANDIDATES, fold_verdict };
-
-export {
-  issue_fold
-};