@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-HRN73FQJ.js

@@ -0,0 +1,77 @@
+import {
+  inherited_scope
+} from "./chunk-5OF2B4BF.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+
+// scripts/run/ship/run-ship-lap.ts
+import { z } from "zod";
+var ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
+var PARENT_SEPARATOR = " \u203A ";
+var STARTUP_STEP = "startup";
+var lap_scope_schema = z.object({
+  issue: z.number(),
+  stage: z.string(),
+  parent: z.string().optional()
+});
+var STEP = {
+  PRECONDITIONS: "preconditions",
+  SCOPED_PAIR: "scoped pair",
+  GATE: "josh gate",
+  OVERLAP_WAIT: "overlap wait",
+  LOCAL_COMMIT: "local commit",
+  MERGE: "merge",
+  PUSH: "push",
+  COMMIT: "josh git"
+};
+var scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema);
+async function to_ledger(lap) {
+  await lane_ledger_write.record_ship_lap(lap);
+}
+async function within(issue, stage, run, parent) {
+  return await scope.within({ issue: Number(issue), stage, parent }, run);
+}
+function current_scope() {
+  return scope.current();
+}
+function environment(parent) {
+  const current = current_scope();
+  if (current === void 0) return {};
+  return {
+    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
+  };
+}
+function lap_of(current, step, started_ms, note) {
+  const { parent, ...place } = current;
+  const name = parent === void 0 ? step : `${parent}${PARENT_SEPARATOR}${step}`;
+  return { ...place, step: name, elapsed_ms: performance.now() - started_ms, ...note };
+}
+function no_note() {
+  return {};
+}
+var startup = { recorded: false };
+async function record_startup(current, sink, is_wanted) {
+  if (!is_wanted || startup.recorded || scope.local() !== void 0) return;
+  startup.recorded = true;
+  await sink(lap_of(current, STARTUP_STEP, 0, {}));
+}
+async function timed(step, run, { sink = to_ledger, note_of = no_note, startup: with_startup } = {}) {
+  const current = current_scope();
+  if (current === void 0) return await run();
+  await record_startup(current, sink, with_startup !== false);
+  const started_ms = performance.now();
+  const noted = { note: {} };
+  try {
+    const result = await run();
+    noted.note = note_of(result);
+    return result;
+  } finally {
+    await sink(lap_of(current, step, started_ms, noted.note));
+  }
+}
+var run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
+
+export {
+  run_ship_lap
+};

package/dist/commands/chunk-HYE3MBAN.js

@@ -0,0 +1,113 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-LS7P324N.js";
+import {
+  ISSUE_FIELDS,
+  STATE_AND_RELATIONS_FIELDS,
+  git_gh_issue_graphql,
+  git_gh_issue_rest,
+  issue_fields_schema
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_transport
+} from "./chunk-LX2ENXHZ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-batch-graphql.ts
+import { z } from "zod";
+var ALIAS_PREFIX = "issue";
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+var repository_schema = z.record(z.string(), z.unknown());
+var data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
+var response_schema = z.looseObject({ data: data_schema });
+function alias_of(issue_number) {
+  return `${ALIAS_PREFIX}${String(issue_number)}`;
+}
+function query_of(issue_numbers) {
+  const aliases = issue_numbers.map(
+    (issue_number) => `${alias_of(issue_number)}: issueOrPullRequest(number: ${String(issue_number)}) { ... on Issue { ${ISSUE_FIELDS} } }`
+  );
+  return `query($owner: String!, $name: String!) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
+}`;
+}
+function answered(json) {
+  return { kind: "read", json };
+}
+function to_read(issue, fields) {
+  const issue_json = git_gh_issue_rest.to_gh_issue(
+    git_gh_issue_graphql.to_rest_issue(issue),
+    git_gh_issue_rest.split_fields(fields),
+    git_gh_issue_graphql.to_blocked_by(issue)
+  );
+  return answered(JSON.stringify(issue_json));
+}
+async function query_chunk(issue_numbers, variables) {
+  const json = await git_gh_transport.query_partial({ query: query_of(issue_numbers), variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, response_schema)?.data;
+}
+function answered_reads(request, data) {
+  return request.issue_numbers.flatMap((issue_number) => {
+    const issue = issue_fields_schema.safeParse(data.repository[alias_of(issue_number)]);
+    return issue.success ? [[issue_number, to_read(issue.data, request.fields)]] : [];
+  });
+}
+function with_chunk(batch, request, data) {
+  if (data === void 0) return batch;
+  return {
+    reads: new Map([...batch.reads, ...answered_reads(request, data)]),
+    cost: batch.cost + data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+function empty_batch() {
+  return { reads: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
+}
+async function read_many(issue_numbers, repo, fields = STATE_AND_RELATIONS_FIELDS) {
+  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
+  let batch = empty_batch();
+  if (variables === void 0) return batch;
+  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
+  for (const chunk of chunks) {
+    const request = { issue_numbers: chunk, fields };
+    batch = with_chunk(batch, request, await query_chunk(chunk, variables));
+  }
+  return batch;
+}
+var git_gh_issue_batch_graphql = { answered, empty_batch, read_many };
+
+// scripts/gh/git-gh-issue-batch-read.ts
+async function read_each(issue_numbers, reader) {
+  const { reads } = await git_gh_issue_batch_graphql.read_many(
+    issue_numbers,
+    reader.repo,
+    reader.fields
+  );
+  return await Promise.all(
+    issue_numbers.map(async (issue_number) => {
+      const read = reads.get(issue_number);
+      const value = read?.kind === "read" ? reader.from_json(read.json) : await reader.read_rest(issue_number);
+      return [issue_number, value];
+    })
+  );
+}
+async function read_across(issues, reader_for) {
+  const repos = [...new Set(issues.map((issue) => issue.repo))];
+  const reads = await Promise.all(
+    repos.map(async (repo) => {
+      const numbers = issues.filter((issue) => issue.repo === repo).map((issue) => issue.number);
+      return new Map(await read_each(numbers, reader_for(repo)));
+    })
+  );
+  return issues.map((issue) => reads[repos.indexOf(issue.repo)]?.get(issue.number));
+}
+var git_gh_issue_batch_read = { read_across, read_each };
+
+export {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+};

package/dist/commands/chunk-IAB6LCJL.js

@@ -0,0 +1,18 @@
+import {
+  hook_decision
+} from "./chunk-GB2BRQVL.js";
+
+// scripts/run/run-retrospective.ts
+var RETROSPECTIVE_ENV_KEY = "JOSH_RETROSPECTIVE";
+function is_enabled() {
+  return hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY);
+}
+function is_owed(facts) {
+  if (!facts.is_retrospective_enabled) return false;
+  return !facts.is_lane_child && !facts.is_retrospective_done && !facts.is_consumer;
+}
+var run_retrospective = { is_enabled, is_owed };
+
+export {
+  run_retrospective
+};

package/dist/commands/chunk-IAGENI2U.js

@@ -0,0 +1,42 @@
+import {
+  has_stderr_field
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/gh/git-gh-helpers.ts
+function parse_pr_state_string(result) {
+  const trimmed = result.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function is_pr_already_exists_message(error_message) {
+  return error_message.toLowerCase().includes("already exists");
+}
+function get_error_message_with_stderr(error) {
+  if (!(error instanceof Error)) return String(error);
+  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
+${error.stderr}`;
+  return error.message;
+}
+function handle_pr_create_error(error) {
+  const error_message = get_error_message_with_stderr(error);
+  if (is_pr_already_exists_message(error_message)) {
+    throw new Error("PR_ALREADY_EXISTS");
+  }
+  throw error;
+}
+var git_gh_helpers = {
+  parse_pr_state_string,
+  get_error_message_with_stderr,
+  handle_pr_create_error
+};
+
+// scripts/gh/git-gh-rest-state.ts
+var MERGED_STATE = "MERGED";
+function to_gh_state(state) {
+  return state?.toUpperCase();
+}
+
+export {
+  git_gh_helpers,
+  MERGED_STATE,
+  to_gh_state
+};

package/dist/commands/chunk-ICPVBHIX.js

@@ -0,0 +1,48 @@
+import {
+  run_carry_reclaim
+} from "./chunk-SKGDMAIA.js";
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_provider,
+  cost_transcript
+} from "./chunk-DDZVMXZD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/wake/run-wake-handoff.ts
+import { existsSync } from "node:fs";
+function session_owner(session) {
+  if (session.provider === agent_provider.OPENAI_PROVIDER) {
+    return { session: session.session_id, is_headless: true };
+  }
+  const directory = cost_transcript.transcript_directory(session.worktree);
+  const transcript = run_carry_conversation.transcript_of(session.session_id, directory);
+  return { transcript, is_headless: true };
+}
+function hand_off(target) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried" || read.carry.is_handed_off === true) return;
+  stamp_file.replace_stamp(target, { ...read.carry, is_handed_off: true });
+}
+function hand_to(target, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return;
+  run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider });
+}
+function hand_on(target, owner, pid) {
+  if (owner.transcript === void 0 && owner.session === void 0) return;
+  const process_owner = run_carry.owner_of(pid, void 0, owner.transcript);
+  run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session });
+}
+function has_session_begun(carry) {
+  return carry.owner_transcript === void 0 || existsSync(carry.owner_transcript);
+}
+var run_wake_handoff = { hand_off, session_owner, hand_to, hand_on, has_session_begun };
+
+export {
+  run_wake_handoff
+};

package/dist/commands/chunk-IEKW3ON6.js

@@ -0,0 +1,161 @@
+import {
+  epic_blocked_by
+} from "./chunk-TMFKVJUW.js";
+import {
+  stash_push_cli
+} from "./chunk-UVY5ODCM.js";
+import {
+  main_merge_guard
+} from "./chunk-HE3GOMR7.js";
+import {
+  run_hold_cli
+} from "./chunk-GWTBIGYC.js";
+import {
+  run_pause_comment
+} from "./chunk-YNCF66RK.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/run/pause/run-set-aside-commit.ts
+var COMMAND = "run:pause";
+var RERUN = "the command that paused (`run:pause`, `run:split`)";
+var COMMITTED_VERDICT = "committed";
+var CLEAN_VERDICT = "clean";
+var ALREADY = "already";
+async function is_lane(issue) {
+  return await git_command.branch() === lane_paths.lane_branch(issue);
+}
+function message_of(stash_message) {
+  return `wip: ${stash_message}`;
+}
+async function is_committed(stash_message) {
+  return await git_spawn.read(["log", "-1", "--format=%s"]) === message_of(stash_message);
+}
+async function commit(stash_message) {
+  if (await is_committed(stash_message)) return ALREADY;
+  const unmerged = await git_stash.unmerged_paths();
+  if (unmerged.length > 0) {
+    throw new Error(main_merge_guard.unresolved_message(COMMAND, unmerged, RERUN));
+  }
+  if (!await git_stash.has_stashable_changes()) return CLEAN_VERDICT;
+  await git_spawn.read(["add", "-A", "--", ":/"]);
+  await git_spawn.read(["commit", "--no-verify", "-m", message_of(stash_message)]);
+  return COMMITTED_VERDICT;
+}
+var run_set_aside_commit = { is_lane, is_committed, message_of, commit };
+
+// scripts/run/pause/run-set-aside.ts
+var SUCCESS_EXIT_CODE = 0;
+var ALREADY2 = "already";
+async function is_stashed(request) {
+  return git_stash.select(await git_stash.list(), request.stash_message).kind !== "none";
+}
+async function stash(request) {
+  if (await is_stashed(request)) return ALREADY2;
+  return await stash_push_cli.set_aside({ message: request.stash_message, dir: void 0 });
+}
+async function is_committed_aside(request) {
+  if (request.is_handed_off === true) return false;
+  return await run_set_aside_commit.is_lane(request.issue);
+}
+async function set_aside(request) {
+  if (!await is_committed_aside(request)) return await stash(request);
+  return await run_set_aside_commit.commit(request.stash_message);
+}
+var NOTHING_SET_ASIDE = "- The tree held no uncommitted work, so nothing was set aside.";
+function committed_line(request) {
+  const message = run_set_aside_commit.message_of(request.stash_message);
+  return `- The work in progress was committed on the lane branch as \`${message}\`. To resume, run \`pnpm josh main:merge\` on the lane and continue.`;
+}
+function stashed_line(request) {
+  return `- The work in progress was stashed. After \`pnpm josh ms\`, recover it with \`pnpm josh stash:pop "${request.stash_message}"\`.`;
+}
+async function work_line(request) {
+  if (await is_committed_aside(request)) {
+    const is_committed2 = await run_set_aside_commit.is_committed(request.stash_message);
+    return is_committed2 ? committed_line(request) : NOTHING_SET_ASIDE;
+  }
+  return await is_stashed(request) ? stashed_line(request) : NOTHING_SET_ASIDE;
+}
+async function comment(request) {
+  if (await run_pause_comment.has_comment(request)) return ALREADY2;
+  const body = [request.headline, await work_line(request), request.marker].join("\n");
+  return await git_gh_issue_write.issue_comment(request.issue, body);
+}
+async function release(issue) {
+  const code = await run_hold_cli.run(["--release", issue]);
+  if (code !== SUCCESS_EXIT_CODE) throw new Error("`run:release` refused");
+  return "released";
+}
+async function attempt(act) {
+  try {
+    return { detail: await act() };
+  } catch (error) {
+    return { reason: error_text.message_of(error) };
+  }
+}
+async function run_steps(steps) {
+  const done = [];
+  for (const [step, act] of steps) {
+    const outcome = await attempt(act);
+    if ("reason" in outcome) return { kind: "failed", step, reason: outcome.reason, done };
+    done.push({ step, detail: outcome.detail });
+  }
+  return { kind: "done", done };
+}
+function steps_of(request, between = []) {
+  return [
+    ["set-aside", async () => await set_aside(request)],
+    ["comment", async () => await comment(request)],
+    ...between,
+    ["release", async () => await release(request.issue)]
+  ];
+}
+var run_set_aside = { steps_of, run_steps };
+
+// scripts/run/pause/run-pause.ts
+function aside_of(request) {
+  const issue = issue_cite.plain_for("program", request.issue);
+  const prerequisite = issue_cite.plain_for("program", request.prerequisite);
+  return {
+    issue: request.issue,
+    stash_message: `run:pause: ${issue} waits on ${prerequisite}`,
+    marker: `${run_pause_comment.marker_of(request.issue)}${prerequisite} -->`,
+    headline: `Paused: ${prerequisite} has to land first.`
+  };
+}
+var NO_STEPS = { before: [], after: [] };
+async function pause(request, around = NO_STEPS) {
+  const steps = run_set_aside.steps_of(aside_of(request), [
+    ...around.before,
+    ["blocked-by", async () => await epic_blocked_by.record(request)],
+    ...around.after
+  ]);
+  const result = await run_set_aside.run_steps(steps);
+  return result.kind === "done" ? { kind: "paused", done: result.done } : result;
+}
+var run_pause = { pause, aside_of };
+
+export {
+  run_set_aside,
+  run_pause
+};

package/dist/commands/chunk-IOKOHB7P.js

@@ -0,0 +1,109 @@
+import {
+  review_round2
+} from "./chunk-T6JUDQMW.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_code_tree
+} from "./chunk-62NYXZCC.js";
+import {
+  review_attest
+} from "./chunk-URZ4RDC4.js";
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+
+// scripts/review/review-interaction.ts
+var TARGET_DIRECTORIES = ["scripts/run/", "scripts/lane/", "scripts/backlog/", "scripts/hooks/"];
+var NOT_DUE_LINE = "Interaction review not due: this is not the kit repository, or the change touches none of scripts/run/, scripts/lane/, scripts/backlog/ or scripts/hooks/.";
+var QUESTIONS = [
+  "1. Every state, command, label, file or process this change adds or gives a new meaning to \u2014 who else reads or writes it? Search the repository outside the diff for each. Where the plan has a `### \u5F71\u97FF\u3092\u53D7\u3051\u308B\u65E2\u5B58\u306E\u5229\u7528\u8005` section, check it names them all.",
+  "2. Does each of those readers and writers still behave correctly when the new state or value reaches it (for example, a paused lane counted as running)?",
+  "3. Does the change add heavy or synchronous work to a path called repeatedly \u2014 every second, every Bash call, every edit?"
+];
+var ROLE_LINES = [
+  "## Interaction review",
+  "This pass is not a second `/code-review`: do not hunt for bugs inside the diff \u2014 the round before it did. Your role is to find three existing features this change breaks. Check only these three:",
+  ...QUESTIONS,
+  "Report each break with the reader's `file:line` and the change's, rated by the rubric's severities; it is disposed of by `prompts/review.md` \u2192 \"Interaction review\"."
+];
+var INERT_LINE_PREFIX = "Interaction review not due: every run-tooling path this change touches leaves what executes unchanged (round 2\u2019s inert reading \u2014 in these directories, an edit to comments or import specifiers only)";
+var NOT_REQUIRED = "not-required";
+function due_paths(paths, checkout = process.cwd()) {
+  if (!project_checks.is_kit_repository(checkout)) return [];
+  return paths.filter((file) => TARGET_DIRECTORIES.some((directory) => file.startsWith(directory)));
+}
+function brief_block(targets) {
+  const listed = targets.map((file) => `- ${file}`);
+  return [...ROLE_LINES, "Changed in the run tooling:", ...listed].join("\n");
+}
+async function inert_line(due) {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) return void 0;
+  const inert = await review_code_tree.inert_since(base, due);
+  const is_inert = due.every((relative) => review_round2.is_unexecuted(relative, inert));
+  return is_inert ? `${INERT_LINE_PREFIX}: ${due.join(", ")}` : void 0;
+}
+async function unrecorded_reading(due) {
+  const line = await inert_line(due);
+  return line === void 0 ? { status: "missing" } : { status: NOT_REQUIRED, inert_line: line };
+}
+async function reading_of(issue, paths, root = observation_ledger_home.ledger_root()) {
+  const due = due_paths(paths);
+  const content = due.length > 0 ? await observation_ledger_home.read(root) : void 0;
+  if (content === void 0) return { status: NOT_REQUIRED };
+  if (review_finding_ledger.has_issue_record(content, issue, "interaction")) return { status: "ok" };
+  return await unrecorded_reading(due);
+}
+async function status_of(issue, paths, root) {
+  const answer = await reading_of(issue, paths, root);
+  return answer.status;
+}
+async function reading(issue, root) {
+  return await reading_of(issue, await changed_paths.read_changed_paths(false), root);
+}
+async function status(issue, root) {
+  const answer = await reading(issue, root);
+  return answer.status;
+}
+function round_one_slots(answer) {
+  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
+  return answer === "missing" ? [CODE, INTERACTION] : [CODE];
+}
+var MISSING_REASON = "This change touches the run tooling, and no interaction review is recorded for its issue \u2014 the pass that looks for the existing features a change breaks, which `/code-review` does not (joshuafolkken/kit#4276).";
+var REMEDY = "Run it from `pnpm josh review:brief --interaction`, whose reviewer writes its findings with `pnpm josh review:submit --interaction`; record them with `pnpm josh review:record --from-slot --interaction --issue <N> [<n>=<disposition> ...]` and reissue the merge.";
+function refusal_message(issue) {
+  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
+}
+async function refusal(issue, root) {
+  return await status(issue, root) === "missing" ? refusal_message(issue) : void 0;
+}
+var review_interaction = {
+  brief_block,
+  due_paths,
+  NOT_DUE_LINE,
+  QUESTIONS,
+  reading,
+  refusal,
+  refusal_message,
+  round_one_slots,
+  status,
+  status_of
+};
+
+export {
+  review_interaction
+};