@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-UX3HCPLX.js

@@ -0,0 +1,449 @@
+import {
+  lane_value_missing
+} from "./chunk-AJWR7D3H.js";
+import {
+  lane_launch_cli
+} from "./chunk-B545ENGY.js";
+import {
+  lane_vacant
+} from "./chunk-YOZTZMAT.js";
+import {
+  backlog_drive_unit
+} from "./chunk-2E6PSONB.js";
+import {
+  issue_measured_close
+} from "./chunk-PF3PMT2Q.js";
+import {
+  epic_validate
+} from "./chunk-RFWB2KAV.js";
+import {
+  trusted_measure
+} from "./chunk-GNTTGRCX.js";
+import {
+  run_carry_ended
+} from "./chunk-KPAJBJXG.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  lane_implement_rate_read
+} from "./chunk-PJYTUUTH.js";
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  EPIC_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+
+// scripts/backlog/backlog-drive-seats.ts
+async function seated(issues, ports) {
+  const kept = await Promise.all(issues.map(async (issue) => await ports.has_lane(issue)));
+  const room = await ports.limit_room();
+  const available = Math.min(await ports.free_lanes(), room);
+  const resumed = issues.filter((_issue, index) => kept[index] === true).slice(0, available);
+  const fresh_room = available - resumed.length;
+  return [
+    ...resumed,
+    ...issues.filter((_issue, index) => kept[index] !== true).slice(0, fresh_room)
+  ];
+}
+async function has_kept_lane(issue) {
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane?.output === void 0) return false;
+  return !await lane_vacant.is_vacant(lane);
+}
+var backlog_drive_seats = { has_kept_lane, seated };
+
+// scripts/backlog/backlog-drive-owner.ts
+import { existsSync } from "node:fs";
+var READ_ATTEMPTS = 6;
+var ENDED_MESSAGE = "The carry record is no longer active.";
+var seen = {};
+function owns_record(carry, owner) {
+  const current = run_carry.owner_of(Number(owner));
+  const has_owner = carry.owner_pid === current.pid && carry.owner_start === current.start;
+  return has_owner && run_carry.is_owner_live(carry) && !carry.is_handed_off;
+}
+function is_ended(directory) {
+  return run_carry_ended.has_ended(run_carry_ended.ended_path(directory), seen.started_at);
+}
+function unread_note(read, directory) {
+  const presence = existsSync(run_carry.carry_path(directory)) ? "present" : "absent";
+  return `The carry record read \`${read.kind}\` with its file ${presence}`;
+}
+function is_settled(read, directory) {
+  if (read.kind === "carried" || is_ended(directory)) return true;
+  console.error(`${unread_note(read, directory)}; reading it again.`);
+  return false;
+}
+async function read_record(directory) {
+  const target = run_carry.carry_path(directory);
+  let read = { kind: "none" };
+  await poll.poll_until(
+    async () => {
+      read = run_carry.read_carry(target);
+      return is_settled(read, directory);
+    },
+    {
+      attempts: READ_ATTEMPTS,
+      interval_ms: backlog_budget.OFFER_INTERVAL_MS,
+      sleeper: async (duration_ms) => {
+        await poll.sleep(duration_ms);
+      }
+    }
+  );
+  return read;
+}
+function unread_message(read, directory) {
+  if (is_ended(directory)) return ENDED_MESSAGE;
+  return `${unread_note(read, directory)}, ${String(READ_ATTEMPTS)} times in a row.`;
+}
+async function assert_current(owner) {
+  const directory = await run_carry.repository_directory();
+  if (directory === void 0) throw new Error("The carry record cannot be located.");
+  const read = await read_record(directory);
+  if (read.kind !== "carried") throw new Error(unread_message(read, directory));
+  if (!owns_record(read.carry, owner)) {
+    throw new Error("The driver no longer owns the carry record.");
+  }
+  seen.started_at = read.carry.started_at;
+  return read.carry;
+}
+var backlog_drive_owner = { READ_ATTEMPTS, assert_current };
+
+// scripts/backlog/backlog-drive-launch-pass.ts
+var NO_FREE_LANES = 0;
+var LAUNCHED = "launched";
+var UNOPENED = "unopened";
+var MEASURED_LAUNCH = "measured";
+var UNSAMPLED_LAUNCH = "unsampled";
+var SPLIT_LAUNCH = "split";
+async function handed_back(issue, outcome2, state, ports) {
+  await ports.stall(issue, outcome2);
+  return { kind: "end", end: { reason: "launch", token: void 0, issue }, state };
+}
+async function refused(issue, outcome2, state, ports) {
+  if (outcome2 === "waiting") return { kind: "continue", state };
+  if (outcome2 !== UNOPENED) return await handed_back(issue, outcome2, state, ports);
+  if (await ports.free_lanes() <= NO_FREE_LANES) return { kind: "continue", state };
+  return await handed_back(issue, outcome2, state, ports);
+}
+function launched(state, settled, ports) {
+  const { in_flight, measured: measured3, unsampled } = settled;
+  const exclude = [...state.exclude, ...measured3];
+  const waiting = [...state.waiting ?? [], ...unsampled];
+  if (in_flight.length === state.in_flight.length && measured3.length === 0) {
+    return { ...state, in_flight, exclude, waiting };
+  }
+  return { ...state, in_flight, exclude, waiting, active: ports.now().toISOString() };
+}
+var SETTLED = /* @__PURE__ */ new Set([
+  MEASURED_LAUNCH,
+  LAUNCHED,
+  UNSAMPLED_LAUNCH,
+  SPLIT_LAUNCH
+]);
+function is_settled2(outcome2) {
+  return SETTLED.has(outcome2);
+}
+function settle(settled, issue, outcome2) {
+  if (outcome2 === MEASURED_LAUNCH || outcome2 === SPLIT_LAUNCH) settled.measured.push(issue);
+  if (outcome2 === UNSAMPLED_LAUNCH) settled.unsampled.push(issue);
+  if (outcome2 === LAUNCHED) settled.in_flight.push(issue);
+}
+async function launch_each(issues, ports) {
+  const results = await Promise.allSettled(
+    issues.map(async (issue) => ({ issue, outcome: await ports.launch(issue) }))
+  );
+  const failure = results.find((result) => result.status === "rejected");
+  if (failure !== void 0) throw failure.reason;
+  return results.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+}
+async function launch_all(issues, state, ports) {
+  const settled = { in_flight: [...state.in_flight], measured: [], unsampled: [] };
+  const launching = await backlog_drive_seats.seated(issues, ports);
+  const outcomes = await launch_each(launching, ports);
+  for (const { issue, outcome: outcome2 } of outcomes) settle(settled, issue, outcome2);
+  const refusal = outcomes.find(({ outcome: outcome2 }) => !is_settled2(outcome2));
+  const next = launched(state, settled, ports);
+  if (refusal === void 0) return { kind: "continue", state: next };
+  return await refused(refusal.issue, refusal.outcome, next, ports);
+}
+var backlog_drive_launch_pass = { MEASURED_LAUNCH, SPLIT_LAUNCH, UNSAMPLED_LAUNCH, launch_all };
+
+// scripts/backlog/backlog-drive-split-unit.ts
+function brief_of(issue) {
+  return [
+    `Split-only unit for ${issue_cite.plain_for("program", issue)}: its declared size is over the size bar. Implement nothing.`,
+    `Read it with \`pnpm josh issue:read ${issue}\` and answer only question 1 of`,
+    `\`pnpm josh doc:section .claude/skills/workflow-commands/split-assessment.md "${split_assess.QUESTION_SECTION}"\`.`,
+    `Separately-mergeable parts \u2192 file each child k with \`pnpm josh issue:file "<title>" --body-file .josh/tmp/split-${issue}-<k>.md --route split\`, then`,
+    `\`pnpm josh epic --promote ${issue} <N1> <N2> ... [--ordered]\`.`,
+    "Before publishing, record every child plan with `issue:plan --planned --no-notify`, then `pnpm josh issue:file --publish <E>`; retry the same epic on failure.",
+    `One deliverable \u2192 add \`${split_assess.REASON_PREFIX} <\u7406\u7531>\` under \u80CC\u666F with \`pnpm josh issue:body ${issue} --body-file -\`.`,
+    "Nobody answers this session: end it once either is written."
+  ].join(" ");
+}
+function is_over_bar(subject, measured3) {
+  const { implement_rate, growth } = measured3;
+  return size_estimate.over_budget(subject.body ?? "", implement_rate, growth) !== void 0;
+}
+function is_split(subject) {
+  if (subject === void 0) return false;
+  return subject.state?.toUpperCase() === "CLOSED" || subject.labels.includes(EPIC_LABEL);
+}
+function production_ports() {
+  return {
+    read: async (issue) => epic_validate.parse_epic_subject(await git_gh_command.issue_get_labels_and_body(issue)),
+    measurements: async () => await lane_implement_rate_read.measurements(),
+    repository_directory: run_carry.repository_directory,
+    launch_attached: backlog_drive_unit.launch_attached,
+    environment: process.env,
+    cwd: process.cwd(),
+    now: () => Date.now()
+  };
+}
+async function request_of(issue, ports) {
+  const git_directory = await ports.repository_directory();
+  if (git_directory === void 0) return void 0;
+  const log = backlog_drive_unit.log_path(git_directory, `split-${issue}`, ports.now());
+  return backlog_drive_unit.request_of(brief_of(issue), ports, log);
+}
+async function is_due(issue, ports) {
+  const subject = await ports.read(issue);
+  return subject !== void 0 && is_over_bar(subject, await ports.measurements());
+}
+async function run(issue, ports = production_ports()) {
+  if (!await is_due(issue, ports)) return "launch";
+  const request = await request_of(issue, ports);
+  if (request === void 0) return "launch";
+  await ports.launch_attached(request);
+  return is_split(await ports.read(issue)) ? "split" : "launch";
+}
+var backlog_drive_split_unit = { run };
+
+// scripts/backlog/backlog-drive-trace.ts
+var STEP = { COLLECT: "collect", LAUNCH: "launch" };
+var EDGE = { START: "start", DONE: "done", FAILED: "failed" };
+function text_of(issue, step, edge) {
+  return `${issue_cite.plain_for("program", issue)} ${step} ${edge}`;
+}
+async function mark(issue, step, edge) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.LANE_PHASE,
+    text_of(issue, step, edge)
+  );
+}
+async function traced(issue, step, run2) {
+  await mark(issue, step, EDGE.START);
+  try {
+    const value = await run2();
+    await mark(issue, step, EDGE.DONE);
+    return value;
+  } catch (error) {
+    await mark(issue, step, EDGE.FAILED);
+    throw error;
+  }
+}
+var backlog_drive_trace = { STEP, traced };
+
+// scripts/backlog/backlog-measure-close.ts
+var FENCE = "```";
+var VERDICT_WORDS = {
+  pass: "within the bound, so the issue is closed without a lane.",
+  fail: "out of the bound, so the issue goes to a lane.",
+  unreadable: "no value could be read from the output, so the issue goes to a lane.",
+  unsampled: "sample condition not met \u2014 no sample to read yet, so the issue waits without a lane."
+};
+function verdict_of(declaration, run2) {
+  if (run2.kind === "ok") return measure_declaration.judge(declaration, run2.output);
+  return lane_value_missing.is_unsampled(run2.message) ? { kind: "unsampled" } : { kind: "unreadable" };
+}
+function measured(declaration, source) {
+  const run2 = trusted_measure.run_command(declaration.command, source);
+  return { declaration, run: run2, verdict: verdict_of(declaration, run2) };
+}
+async function declared(issue) {
+  const body = await git_gh_command.issue_get_body(issue);
+  if (body !== void 0 && measure_declaration.parse(body) === void 0) return void 0;
+  const read = await trusted_measure.read_trusted_body(issue);
+  if (read.kind === "refused") return void 0;
+  const declaration = measure_declaration.parse(read.body);
+  return declaration === void 0 ? void 0 : measured(declaration, read);
+}
+function value_words(verdict) {
+  return "value" in verdict ? String(verdict.value) : verdict.kind;
+}
+function report(measurement) {
+  const { declaration, run: run2, verdict } = measurement;
+  return [
+    "`backlog:drive` ran the measurement declaration.",
+    "",
+    `- Declaration: ${measure_declaration.format(declaration)}`,
+    `- Value: ${value_words(verdict)}`,
+    `- Verdict: ${VERDICT_WORDS[verdict.kind]}`,
+    "",
+    FENCE,
+    trusted_measure.text_of(run2),
+    FENCE
+  ].join("\n");
+}
+async function close_passed(issue, measurement) {
+  const is_closed = await issue_measured_close.close(issue, report(measurement));
+  const value = value_words(measurement.verdict);
+  const bound = `${measurement.declaration.operator} ${String(measurement.declaration.threshold)}`;
+  if (is_closed) {
+    await run_event_stream_emit.emit(
+      run_event_stream.EVENT_KIND.MEASURED,
+      `${issue_cite.plain_for("program", issue)} measured by backlog:drive: ${value} ${bound}`
+    );
+  }
+  return is_closed;
+}
+async function waited(issue) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.SAMPLE_WAIT,
+    `${issue_cite.plain_for("program", issue)} waiting: sample condition not met`
+  );
+  return "wait";
+}
+async function hand_over(issue, measurement) {
+  try {
+    await git_gh_command.issue_comment(issue, report(measurement));
+  } catch (error) {
+    console.error(`Measurement result not posted: ${error_text.message_of(error)}`);
+  }
+  return measurement.verdict.kind === "unsampled" ? await waited(issue) : "launch";
+}
+async function outcome(issue) {
+  const measurement = await declared(issue);
+  if (measurement === void 0) return "launch";
+  if (measurement.verdict.kind !== "pass") return await hand_over(issue, measurement);
+  return await close_passed(issue, measurement) ? "closed" : "launch";
+}
+var backlog_measure_close = { outcome };
+
+// scripts/backlog/backlog-drive-launch.ts
+var { MEASURED_LAUNCH: MEASURED_LAUNCH2, SPLIT_LAUNCH: SPLIT_LAUNCH2, UNSAMPLED_LAUNCH: UNSAMPLED_LAUNCH2 } = backlog_drive_launch_pass;
+var LATEST_STASH_MESSAGE = "backlogrun: josh latest before lanes";
+async function latest_stash() {
+  const selection = git_stash.select(await git_stash.list(), LATEST_STASH_MESSAGE);
+  if (selection.kind === "ambiguous") {
+    console.error(
+      `Launching without the "${LATEST_STASH_MESSAGE}" stash: ${selection.selectors.join(", ")} all match \u2014 keep one.`
+    );
+  }
+  return selection.kind === "match" ? LATEST_STASH_MESSAGE : void 0;
+}
+var stash_holders = /* @__PURE__ */ new Set();
+async function launch_ready(issue) {
+  const { launch_ready_lane } = lane_launch_cli;
+  if (stash_holders.size > 0) return await launch_ready_lane({ issue, stash: void 0 });
+  stash_holders.add(issue);
+  try {
+    return await launch_ready_lane({ issue, stash: await latest_stash() });
+  } finally {
+    stash_holders.delete(issue);
+  }
+}
+var DETAIL_LIMIT = 200;
+function no_child(issue, detail) {
+  const event = run_event_setup.no_child(issue);
+  if (detail === void 0) return event;
+  const folded = detail.replaceAll(/\s+/gu, " ");
+  const capped = folded.length > DETAIL_LIMIT ? `${folded.slice(0, DETAIL_LIMIT)}\u2026` : folded;
+  return `${event}: ${capped}`;
+}
+async function measured2(issue) {
+  const outcome2 = await backlog_measure_close.outcome(issue);
+  if (outcome2 === "closed") return MEASURED_LAUNCH2;
+  return outcome2 === "wait" ? UNSAMPLED_LAUNCH2 : void 0;
+}
+async function launch_and_report(issue) {
+  await run_event_setup.emit(run_event_setup.opening_lane(issue));
+  const outcome2 = await launch_ready(issue);
+  if (outcome2.kind !== "launched" && outcome2.kind !== "waiting") {
+    await run_event_setup.emit(no_child(issue, outcome2.detail));
+  }
+  return outcome2.kind;
+}
+async function opened(issue, owner) {
+  await backlog_drive_owner.assert_current(owner);
+  const settled = await run_startup.phase("measurement", async () => await measured2(issue), {
+    edge_of: (value) => value === UNSAMPLED_LAUNCH2 ? "waiting" : "done"
+  });
+  if (settled !== void 0) return settled;
+  const split = await run_startup.phase(
+    "split assessment",
+    async () => await backlog_drive_split_unit.run(issue)
+  );
+  if (split === "split") return SPLIT_LAUNCH2;
+  await backlog_drive_owner.assert_current(owner);
+  return await launch_and_report(issue);
+}
+function launch_edge(value) {
+  return value === "unopened" || value === "failed" ? "failed" : "done";
+}
+async function launch(issue, owner) {
+  return await run_startup.phase(
+    "launch",
+    async () => await backlog_drive_trace.traced(
+      issue,
+      backlog_drive_trace.STEP.LAUNCH,
+      async () => await opened(issue, owner)
+    ),
+    {
+      issue,
+      root: true,
+      edge_of: (value) => value === "waiting" || value === "unsampled" ? "waiting" : launch_edge(value)
+    }
+  );
+}
+var backlog_drive_launch = { LATEST_STASH_MESSAGE, launch };
+
+export {
+  backlog_drive_seats,
+  backlog_drive_launch_pass,
+  backlog_drive_owner,
+  backlog_drive_trace,
+  backlog_drive_launch
+};

package/dist/commands/chunk-UY62WJV6.js

@@ -0,0 +1,120 @@
+import {
+  git_pr
+} from "./chunk-NABSSY4P.js";
+import {
+  live_evidence
+} from "./chunk-HALHQILI.js";
+import {
+  git_issue
+} from "./chunk-QTVVFV4Q.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.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
+};