@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-NV6Y4U37.js

@@ -0,0 +1,338 @@
+import {
+  split_resolution
+} from "./chunk-72Y7PXUJ.js";
+import {
+  auto_ok_cli
+} from "./chunk-N2EE7MMH.js";
+import {
+  size_estimate
+} from "./chunk-IAA73DWD.js";
+import {
+  lane_implement_rate_read
+} from "./chunk-K2VIKG5M.js";
+import {
+  declared_growth,
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-UJFEMO6X.js";
+import {
+  run_ship_planned
+} from "./chunk-QGTLTPXT.js";
+import {
+  backlog_overlap,
+  lane_plan,
+  lane_plan_approval
+} from "./chunk-JUQN3OXG.js";
+import {
+  test_related_cap
+} from "./chunk-BJQDQAQU.js";
+import {
+  test_pinned_logic
+} from "./chunk-I36PDO6I.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  IN_PROGRESS_LABEL,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.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 past the cap 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-NWMY2QJJ.js

@@ -0,0 +1,133 @@
+import {
+  baseline_measure
+} from "./chunk-RH4LJ4D6.js";
+import {
+  measure_declaration
+} from "./chunk-2GJ3WJVT.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec,
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/issue/trusted-measure.ts
+import { execSync } from "node:child_process";
+
+// scripts/issue/trusted-measure-source.ts
+import { z } from "zod";
+var QUERY = "query($id: ID!) { node(id: $id) { ... on Issue { body authorAssociation author { login } editor { login } lastEditedAt } } }";
+var actor_schema = z.object({ login: z.string().min(1) });
+var source_schema = z.object({
+  body: z.string(),
+  authorAssociation: z.string(),
+  author: actor_schema.nullable(),
+  editor: actor_schema.nullable(),
+  lastEditedAt: z.string().nullable()
+});
+var response_schema = z.object({ data: z.object({ node: source_schema }) });
+var node_schema = z.object({ node_id: z.string().min(1) });
+async function read(issue) {
+  try {
+    const rest = await git_gh_issue_read.issue_view_json(issue, "node_id");
+    const node = parse_json_object_or_undefined(rest ?? "", node_schema);
+    if (node === void 0) return void 0;
+    const json = await git_gh_exec.exec_gh_api({
+      path: "graphql",
+      body: JSON.stringify({ query: QUERY, variables: { id: node.node_id } })
+    });
+    return parse_json_object_or_undefined(json, response_schema)?.data.node;
+  } catch {
+    return void 0;
+  }
+}
+var trusted_measure_source = { read };
+
+// scripts/issue/trusted-measure.ts
+var MEASURE_TIMEOUT_MS = 6e4;
+function declared_commands(body) {
+  const baselines = baseline_measure.parse_baselines(body).map((baseline) => baseline.command);
+  const declaration = measure_declaration.parse(body);
+  const premises = measure_declaration.premises(body).map((premise) => premise.command);
+  const declared = declaration === void 0 ? [] : [declaration.command];
+  return [...baselines, ...declared, ...premises];
+}
+function audit(command, source) {
+  console.error(
+    JSON.stringify({
+      event: "trusted-measure",
+      issue: source.issue,
+      author: source.author,
+      editor: source.editor,
+      command
+    })
+  );
+}
+function run_command(command, source) {
+  if (!declared_commands(source.body).includes(command)) {
+    return { kind: "failed", message: "command is not declared in the verified issue body" };
+  }
+  audit(command, source);
+  try {
+    return {
+      kind: "ok",
+      output: execSync(command, { encoding: "utf8", timeout: MEASURE_TIMEOUT_MS }).trim()
+    };
+  } catch (error) {
+    return { kind: "failed", message: error_text.message_of(error) };
+  }
+}
+function text_of(run) {
+  return run.kind === "ok" ? run.output : `(command failed: ${run.message})`;
+}
+function is_unedited(source) {
+  return source.lastEditedAt === null && source.editor === null;
+}
+async function trusted_editor(source) {
+  if (is_unedited(source)) return source.author?.login;
+  const login = source.editor?.login;
+  const is_trusted = await gh_author_association.is_trusted({ login, association: "COLLABORATOR" });
+  return is_trusted ? login : void 0;
+}
+async function trusted_author(issue) {
+  const login = issue.author?.login;
+  if (login === void 0) return void 0;
+  const is_trusted = await gh_author_association.is_trusted({
+    login,
+    association: issue.authorAssociation
+  });
+  return is_trusted ? login : void 0;
+}
+async function read_trusted_body(issue_number) {
+  const issue = await trusted_measure_source.read(issue_number);
+  if (issue === void 0) {
+    return { kind: "refused", reason: `could not read issue ${session_cite.issue(issue_number)}` };
+  }
+  const author = await trusted_author(issue);
+  if (author === void 0) {
+    return {
+      kind: "refused",
+      reason: `refusing ${session_cite.issue(issue_number)}: untrusted author (${issue.authorAssociation})`
+    };
+  }
+  const editor = await trusted_editor(issue);
+  return editor === void 0 ? {
+    kind: "refused",
+    reason: `refusing ${session_cite.issue(issue_number)}: untrusted or unknown last editor`
+  } : { kind: "trusted", body: issue.body, issue: issue_number, author, editor };
+}
+var trusted_measure = { read_trusted_body, run_command, text_of };
+
+export {
+  trusted_measure
+};