@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-5DMFMP4V.js

@@ -0,0 +1,121 @@
+import {
+  epic_add,
+  epic_reconcile
+} from "./chunk-XMNPU3J5.js";
+import {
+  epic_bundle_gaps
+} from "./chunk-N2EE7MMH.js";
+import {
+  epic_index
+} from "./chunk-2ROVUERM.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-blocked-by.ts
+var EPIC_LIMIT = 200;
+var SUCCESS_EXIT_CODE = 0;
+var ALREADY = "already";
+var UNSEEN_EPIC = "the open epics were not read in full, so an epic tracking it may be unseen";
+async function is_blocked(request) {
+  const blockers = await git_gh_issue_read.issue_blocked_by_numbers(request.issue);
+  return blockers.includes(Number(request.prerequisite));
+}
+function is_listed_by(epics, child, epic) {
+  return epic_index.build_tracking_index(epics).get(Number(child))?.includes(epic) === true;
+}
+async function fetch_epics() {
+  const fetched = await epic_index.fetch_epics(EPIC_LIMIT);
+  if (fetched === void 0) throw new Error("the open epics could not be read");
+  return fetched;
+}
+async function tracked_in(issue) {
+  const fetched = await fetch_epics();
+  const epic = epic_index.build_epic_index(fetched.epics).get(Number(issue));
+  if (epic === void 0 && !epic_bundle_gaps.is_membership_established(fetched.cutoff)) {
+    throw new Error(UNSEEN_EPIC);
+  }
+  return { epic, fetched };
+}
+async function tracking_with(issue, children) {
+  const { epic, fetched } = await tracked_in(issue);
+  if (epic === void 0) return void 0;
+  return {
+    epic,
+    lists_children: children.every((child) => is_listed_by(fetched.epics, child, epic))
+  };
+}
+async function tracking_epic(request) {
+  const { epic, fetched } = await tracked_in(request.issue);
+  if (epic === void 0) return void 0;
+  return { epic, is_prerequisite_child: is_listed_by(fetched.epics, request.prerequisite, epic) };
+}
+async function listing_epics(issue) {
+  const fetched = await fetch_epics();
+  if (!epic_bundle_gaps.is_membership_established(fetched.cutoff)) throw new Error(UNSEEN_EPIC);
+  return epic_index.build_tracking_index(fetched.epics).get(Number(issue)) ?? [];
+}
+async function add_to_epic(epic, request) {
+  const code = await epic_add.add_children({
+    epic_number: epic,
+    children: [Number(request.prerequisite)],
+    position: { kind: "before", target: Number(request.issue) }
+  });
+  if (code !== SUCCESS_EXIT_CODE) {
+    throw new Error(`\`epic --add\` into ${session_cite.issue(epic)} failed`);
+  }
+}
+async function record_relation(request) {
+  if (await git_gh_issue_write.issue_add_blocked_by(request.issue, request.prerequisite)) return;
+  throw new Error("the blocked-by relation was not recorded");
+}
+async function refuse_unreconcilable(epic, request) {
+  const link = { blocker: Number(request.prerequisite), blocked: Number(request.issue) };
+  const refusal = await epic_reconcile.refusal_after(epic, link);
+  if (refusal === void 0) return;
+  throw new Error(
+    `\`pnpm josh epic --reconcile ${String(epic)}\` would refuse the relation, so none was recorded: ${refusal}`
+  );
+}
+async function reconcile_epic(epic) {
+  if (await epic_reconcile.reconcile_epic(epic) === SUCCESS_EXIT_CODE) return;
+  throw new Error(
+    `the relation was recorded, but \`pnpm josh epic --reconcile ${String(epic)}\` failed to declare it`
+  );
+}
+async function record_in_epic(tracking, request) {
+  if (tracking.is_prerequisite_child) {
+    await refuse_unreconcilable(tracking.epic, request);
+    await record_relation(request);
+    await reconcile_epic(tracking.epic);
+  } else {
+    await add_to_epic(tracking.epic, request);
+    if (!await is_blocked(request)) await record_relation(request);
+  }
+  return `recorded in epic ${session_cite.issue(tracking.epic)}`;
+}
+async function settle_recorded(request) {
+  const tracking = await tracking_epic(request);
+  if (tracking?.is_prerequisite_child === true) await reconcile_epic(tracking.epic);
+  return ALREADY;
+}
+async function record(request) {
+  if (await is_blocked(request)) return await settle_recorded(request);
+  const tracking = await tracking_epic(request);
+  if (tracking !== void 0 && (request.is_relation_only !== true || tracking.is_prerequisite_child)) {
+    return await record_in_epic(tracking, request);
+  }
+  await record_relation(request);
+  return "recorded";
+}
+var epic_blocked_by = { record, listing_epics, tracking_with };
+
+export {
+  epic_blocked_by
+};

package/dist/commands/chunk-5I3M4B3H.js

@@ -0,0 +1,185 @@
+import {
+  lane_preserve
+} from "./chunk-64II6P7B.js";
+import {
+  run_investigation_record
+} from "./chunk-Q67SPFHV.js";
+import {
+  lane_close
+} from "./chunk-MKIHWQ65.js";
+import {
+  lane_residents
+} from "./chunk-GX5XHW2F.js";
+import {
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  run_label
+} from "./chunk-6NXTP5JT.js";
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-withdraw.ts
+var WITHDRAW_OCCASION = "lane withdraw";
+var CLOSED_STATE = "CLOSED";
+var CLOSED_KIND = "closed";
+var NO_LANE_KIND = "no-lane";
+var UNREADABLE_KIND = "unreadable";
+var OPEN_TAIL = "Its lane child was stopped and the lane closed. The Issue stays open: this run does not resume it, and the next run offers it again.";
+var STAYS_OPEN = "The Issue stays open: this run does not offer it again, the next run does.";
+var WITHDRAWER_TEXT = {
+  person: {
+    name: "a person",
+    cause: "a person withdrew it with `lane:withdraw`",
+    closed_head: "Its lane was withdrawn with `pnpm josh lane:withdraw` after the Issue was closed.",
+    open_head: "Withdrawn from the current run by a person with `pnpm josh lane:withdraw`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  supervisor: {
+    name: "the run:wake supervisor",
+    cause: "the `run:wake` supervisor withdrew it after its issue was closed",
+    closed_head: "Its lane was withdrawn by the `run:wake` supervisor after the Issue was closed.",
+    open_head: "Withdrawn from the current run by the `run:wake` supervisor.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  merge: {
+    name: "the run:merge driver",
+    cause: "`run:merge` withdrew it after its issue was closed without a merge",
+    closed_head: "Its lane was withdrawn by `pnpm josh run:merge` after the Issue was closed without a merge.",
+    open_head: "Withdrawn from the current run by `pnpm josh run:merge`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  yield: lane_yield.YIELD_TEXT
+};
+function withdraw_comment({ reason, by, is_closed }) {
+  const head = is_closed ? WITHDRAWER_TEXT[by].closed_head : WITHDRAWER_TEXT[by].open_head;
+  const tail = is_closed ? "Its lane child was stopped and the lane closed, so it no longer holds a lane and is not resumed." : WITHDRAWER_TEXT[by].open_tail;
+  return [head, tail, `- Why: ${reason}`].join("\n");
+}
+async function record_withdraw(issue, { reason, by }) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.WITHDRAW,
+    `${issue_cite.plain_for("program", issue)} withdrawn by ${WITHDRAWER_TEXT[by].name}: ${reason}`
+  );
+}
+async function read_is_closed(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  if (read.kind !== "state") return void 0;
+  return read.state.state.toUpperCase() === CLOSED_STATE;
+}
+async function forget_investigation(issue, is_closed) {
+  if (!is_closed) return;
+  await run_investigation_record.remove(issue);
+}
+async function note_issue(issue, withdrawal, stash) {
+  const is_noted = await git_gh_issue_write.issue_try_comment(issue, withdraw_comment(withdrawal));
+  if (stash !== void 0) {
+    await lane_preserve.announce(issue, stash, WITHDRAWER_TEXT[withdrawal.by].cause);
+  }
+  await run_label.unmark(issue);
+  await forget_investigation(issue, withdrawal.is_closed);
+  return is_noted;
+}
+async function stop_and_close(lane, withdrawal) {
+  await record_withdraw(lane.issue, withdrawal);
+  const reaped = lane_reap.reap_child(lane).length;
+  const saved = await lane_preserve.keep_work(lane.issue, lane.directory, WITHDRAW_OCCASION);
+  if (saved.kind === "unsaved") return saved;
+  const is_noted = await note_issue(lane.issue, withdrawal, saved.stash);
+  const closed = await lane_close.close_lane(lane.issue);
+  if (closed.kind !== "incomplete") {
+    await lane_state.record_change({ issue: lane.issue, state: "ended", command: "lane:withdraw" });
+  }
+  return {
+    kind: "withdrawn",
+    by: withdrawal.by,
+    reaped,
+    stash: saved.stash,
+    is_noted,
+    is_closed: withdrawal.is_closed,
+    lane: closed.kind,
+    residents: closed.residents
+  };
+}
+async function withdraw(issue, reason, by = "person") {
+  issue_number_shape.require_issue_number(issue);
+  const is_closed = await read_is_closed(issue);
+  if (is_closed === void 0) return { kind: UNREADABLE_KIND };
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: is_closed ? CLOSED_KIND : NO_LANE_KIND };
+  return await stop_and_close(lane, { reason, by, is_closed });
+}
+function stash_sentence(stash) {
+  if (stash === void 0) return "The lane held no uncommitted work.";
+  return `Its uncommitted work was stashed \u2014 recover with \`pnpm josh stash:pop "${stash}"\`.`;
+}
+function lane_suffix(outcome, cited) {
+  const removed = outcome.lane === "incomplete" ? " The lane could not be fully removed." : "";
+  const residents = lane_residents.residents_sentence(outcome.residents, cited);
+  return residents === void 0 ? removed : `${removed} ${residents}`;
+}
+function withdrawn_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  const stopped = outcome.reaped === 0 ? "Its child had already ended." : "Stopped its child.";
+  const head = `Withdrew ${cited}. ${stopped} ${stash_sentence(outcome.stash)}`;
+  const lane = lane_suffix(outcome, cited);
+  const noted = outcome.is_noted ? "" : " The comment saying so could not be posted.";
+  const issue_sentence = outcome.is_closed ? "The Issue was already closed, so its lane no longer holds a place." : WITHDRAWER_TEXT[outcome.by].stays;
+  return `${head} ${issue_sentence}${noted}${lane}`;
+}
+function unsaved_text(outcome, issue) {
+  return `The child for ${session_cite.issue(issue)} was stopped, but its uncommitted work could not be stashed (${outcome.reason}), so the lane is left at ${outcome.directory}; \`run:merge\` books it withdrawn.`;
+}
+function refused_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  if (outcome.kind === CLOSED_KIND) {
+    return `${cited} is already closed and no lane is open for it, so there is nothing to withdraw.`;
+  }
+  if (outcome.kind === NO_LANE_KIND) {
+    return `No lane is open for ${cited}, so there is no child to withdraw.`;
+  }
+  return `The state of ${cited} could not be read, so nothing was stopped or closed \u2014 try again.`;
+}
+function describe(outcome, issue) {
+  if (outcome.kind === "unsaved") return unsaved_text(outcome, issue);
+  return outcome.kind === "withdrawn" ? withdrawn_text(outcome, issue) : refused_text(outcome, issue);
+}
+var WITHDRAWER_NAMES = Object.values(WITHDRAWER_TEXT).map(
+  (text) => text.name
+);
+var lane_withdraw = { WITHDRAWER_NAMES, describe, withdraw };
+
+export {
+  lane_withdraw
+};

package/dist/commands/chunk-5JIMCETI.js

@@ -0,0 +1,104 @@
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  time_transcript_line
+} from "./chunk-ZW6DLYS4.js";
+import {
+  hook_context
+} from "./chunk-HXAVYXUS.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-ledger.ts
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var LEDGER_DIRECTORY = "hook-ledger";
+var LEDGER_EXTENSION = ".jsonl";
+var COMMAND_HEAD = 80;
+var RULE_HEAD = 48;
+var STOP_TOOL = "Stop";
+var COMMAND_FIELDS = ["command", "file_path", "pattern", "url", "prompt"];
+var input_schema = z.record(z.string(), z.unknown());
+var payload_schema = z.object({
+  tool_name: z.string().catch(STOP_TOOL),
+  tool_input: z.unknown().optional(),
+  transcript_path: z.string().catch("")
+});
+var EMPTY_PAYLOAD = payload_schema.parse({});
+var block_schema = z.object({ decision: z.literal("block"), reason: z.string() });
+function rule_of(reason) {
+  const guard = time_transcript_line.guard_from_refusal(reason);
+  return guard === "" ? reason.trim().slice(0, RULE_HEAD) : guard;
+}
+function command_of(input) {
+  const fields = input_schema.safeParse(input).data ?? {};
+  const value = COMMAND_FIELDS.map((key) => fields[key]).find((field) => typeof field === "string");
+  return typeof value === "string" ? value.slice(0, COMMAND_HEAD) : "";
+}
+function entry_of(refusal, branch, now, environment) {
+  const payload = json_value.parse_with(refusal.raw_payload, payload_schema) ?? EMPTY_PAYLOAD;
+  return {
+    at: now.toISOString(),
+    hook: refusal.hook,
+    rule: rule_of(refusal.reason),
+    tool: payload.tool_name,
+    role: environment[agent_session_role.KEY] ?? "",
+    issue: git_branch.issue_from_branch(branch),
+    session: payload.transcript_path,
+    command: command_of(payload.tool_input)
+  };
+}
+function ledger_directory(context = hook_context.from_process()) {
+  if (context.env["VITEST"] !== void 0) return void 0;
+  const common = git_common_directory.repository(context.cwd);
+  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LEDGER_DIRECTORY);
+}
+async function append(entry, directory) {
+  const day = observation_ledger_home.ledger_date(new Date(entry.at));
+  await mkdir(directory, { recursive: true });
+  await appendFile(path.join(directory, `${day}${LEDGER_EXTENSION}`), `${JSON.stringify(entry)}
+`);
+}
+async function record(refusal, directory = ledger_directory(), context = hook_context.from_process()) {
+  if (directory === void 0) return;
+  try {
+    const branch = await git_spawn.read(["-C", context.cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+    await append(entry_of(refusal, branch, /* @__PURE__ */ new Date(), context.env), directory);
+  } catch {
+  }
+}
+async function record_reason(hook, reason, raw_payload, context = hook_context.from_process()) {
+  if (reason !== void 0) {
+    await record({ hook, reason, raw_payload }, ledger_directory(context), context);
+  }
+}
+function blocked_reason(envelope) {
+  return json_value.parse_with(envelope, block_schema)?.reason;
+}
+var hook_ledger = {
+  blocked_reason,
+  command_of,
+  ledger_directory,
+  record,
+  record_reason,
+  rule_of
+};
+
+export {
+  hook_ledger
+};

package/dist/commands/chunk-5KEESWMC.js

@@ -0,0 +1,138 @@
+import {
+  LEDGER_EXCLUSION_PATHSPEC
+} from "./chunk-SV4FZR24.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/git/stash/git-stash.ts
+var ENTRY_SEPARATOR = "\n";
+var FIELD_SEPARATOR = "\0";
+var LIST_FORMAT = "--format=%gd%x00%gs";
+var SUBJECT_MESSAGE_SEPARATOR = ": ";
+var HASH_FORMAT = "--format=%H%x00%gs";
+var HASH_POSITION_FORMAT = "--format=%H%x00%gd";
+var NAME_ONLY_FLAG = "--name-only";
+var ADDED_PREFIX = "+";
+var FILE_HEADER_PREFIX = "+++";
+function to_entry(line) {
+  const [selector, subject] = line.split(FIELD_SEPARATOR);
+  if (selector === void 0 || subject === void 0) return void 0;
+  return { selector, subject };
+}
+function parse_entries(raw) {
+  if (raw === "") return [];
+  return raw.split(ENTRY_SEPARATOR).map((line) => to_entry(line)).filter((entry) => entry !== void 0);
+}
+function matches(subject, message) {
+  return subject === message || subject.endsWith(`${SUBJECT_MESSAGE_SEPARATOR}${message}`);
+}
+function select(entries, message) {
+  const found = entries.filter((entry) => matches(entry.subject, message));
+  const [first] = found;
+  if (first === void 0) return { kind: "none" };
+  if (found.length > 1) {
+    return { kind: "ambiguous", selectors: found.map((entry) => entry.selector) };
+  }
+  return { kind: "match", selector: first.selector };
+}
+function git_args(directory, args) {
+  return directory === void 0 ? args : ["-C", directory, ...args];
+}
+async function list(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", LIST_FORMAT])));
+}
+async function pop(selector, directory) {
+  await git_spawn.read(git_args(directory, ["stash", "pop", selector]));
+}
+async function unmerged_paths(directory) {
+  const unmerged = await git_spawn.read(
+    git_args(directory, ["diff", NAME_ONLY_FLAG, "--diff-filter=U"])
+  );
+  return unmerged.split("\n").filter((line) => line !== "");
+}
+async function has_conflict(directory) {
+  const unmerged = await unmerged_paths(directory);
+  return unmerged.length > 0;
+}
+async function status_of(directory, pathspec = []) {
+  return await git_spawn.read(git_args(directory, ["status", "--porcelain", ...pathspec]));
+}
+async function has_changes(directory, pathspec = []) {
+  const status = await status_of(directory, pathspec);
+  return status !== "";
+}
+var DELETION_STATUS = " D ";
+function holds_work(status) {
+  return status.split(ENTRY_SEPARATOR).some((line) => line !== "" && !line.startsWith(DELETION_STATUS));
+}
+async function has_work(directory) {
+  return holds_work(await status_of(directory));
+}
+var STASHABLE_PATHSPEC = ["--", ...LEDGER_EXCLUSION_PATHSPEC];
+async function has_stashable_changes(directory) {
+  return await has_changes(directory, STASHABLE_PATHSPEC);
+}
+async function push(message, directory, pathspec = []) {
+  await git_spawn.read(git_args(directory, ["stash", "push", "-u", "-m", message, ...pathspec]));
+}
+async function list_by_hash(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", HASH_FORMAT])));
+}
+async function changed_paths(hash, directory) {
+  const raw = await git_spawn.read(
+    git_args(directory, ["stash", "show", "--include-untracked", NAME_ONLY_FLAG, hash])
+  );
+  return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+}
+async function untracked_lines(hash, file, directory) {
+  try {
+    const raw = await git_spawn.read(git_args(directory, ["show", `${hash}^3:${file}`]));
+    return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+  } catch {
+    return [];
+  }
+}
+async function added_lines(hash, file, directory) {
+  const diff = await git_spawn.read(git_args(directory, ["diff", `${hash}^1`, hash, "--", file]));
+  if (diff === "") return await untracked_lines(hash, file, directory);
+  return diff.split(ENTRY_SEPARATOR).filter((line) => line.startsWith(ADDED_PREFIX) && !line.startsWith(FILE_HEADER_PREFIX)).map((line) => line.slice(ADDED_PREFIX.length));
+}
+async function position_of(hash, directory) {
+  const raw = await git_spawn.read(git_args(directory, ["stash", "list", HASH_POSITION_FORMAT]));
+  return parse_entries(raw).find((candidate) => candidate.selector === hash)?.subject;
+}
+async function drop_by_hash(hash, directory) {
+  const position = await position_of(hash, directory);
+  if (position === void 0) return false;
+  await git_spawn.read(git_args(directory, ["stash", "drop", position]));
+  return true;
+}
+function work_message(issue, occasion) {
+  return `${issue}: uncommitted work at ${occasion}`;
+}
+var git_stash = {
+  added_lines,
+  changed_paths,
+  drop_by_hash,
+  has_changes,
+  has_conflict,
+  has_stashable_changes,
+  has_work,
+  holds_work,
+  list,
+  list_by_hash,
+  matches,
+  parse_entries,
+  pop,
+  position_of,
+  push,
+  select,
+  STASHABLE_PATHSPEC,
+  unmerged_paths,
+  work_message
+};
+
+export {
+  git_stash
+};