@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-YUAIWKOM.js

@@ -0,0 +1,132 @@
+import {
+  lane_implement_rate_read
+} from "./chunk-K2VIKG5M.js";
+import {
+  git_path_quoting,
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/split/split-measure.ts
+import { readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/split/split-relocations.ts
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+var PAIR_FIELDS = 2;
+var RAW_OPTIONS = ["diff", "--raw", "-z", "--no-abbrev", "--no-relative", "--no-renames"];
+function raw_changes(raw) {
+  return raw.split("\0").flatMap(
+    (header, index, fields) => index % PAIR_FIELDS === 0 && fields[index + 1] !== void 0 ? { header, file: fields[index + 1] ?? "" } : []
+  );
+}
+function deleted_blobs(raw) {
+  return raw_changes(raw).flatMap(({ header, file }) => {
+    const object = /^:100\d+ \d+ (\w+) \w+ D$/u.exec(header)?.[1];
+    return object === void 0 ? [] : { file, object };
+  });
+}
+function added_paths(raw) {
+  return raw_changes(raw).filter((change) => change.header.endsWith(" A")).map((change) => change.file);
+}
+async function content_object(root, file) {
+  try {
+    const stat = await lstat(path.join(root, file));
+    if (!stat.isFile()) return void 0;
+    return await git_spawn.read(["-C", root, "hash-object", "--no-filters", "--", file]);
+  } catch {
+    return void 0;
+  }
+}
+function pair(deleted, addition) {
+  const index = deleted.findIndex((blob) => blob.object === addition.object);
+  if (index === -1) return [];
+  return deleted.splice(index, 1).flatMap((source) => [source.file, addition.file]);
+}
+function paired_paths(raw, additions) {
+  const deleted = deleted_blobs(raw);
+  const paths = additions.flatMap((addition) => pair(deleted, addition));
+  return new Set(paths.map((file) => git_path_quoting.quote(file)));
+}
+async function candidates(root, files) {
+  return await Promise.all(
+    files.map(async (file) => ({
+      file,
+      object: await content_object(root, file) ?? ""
+    }))
+  );
+}
+async function without_relocations(root, base, numstat, untracked) {
+  const raw = await git_spawn.read([...RAW_OPTIONS, base, "--"]);
+  const added = [...added_paths(raw), ...untracked];
+  const paired = paired_paths(raw, await candidates(root, added));
+  const rows = numstat.split("\n").filter((row) => !paired.has(row.split("	").slice(PAIR_FIELDS).join("	")));
+  return { numstat: rows.join("\n"), added };
+}
+var split_relocations = { without_relocations };
+
+// scripts/split/split-measure.ts
+var UNRESOLVED_BASE = "the change base could not be resolved";
+var NUL_BYTE = 0;
+var NO_CONTENT = Buffer.alloc(0);
+var NEWLINE = "\n";
+function line_count(content) {
+  if (content.includes(NUL_BYTE)) return 0;
+  const text = content.toString("utf8");
+  const newlines = text.split(NEWLINE).length - 1;
+  return text === "" || text.endsWith(NEWLINE) ? newlines : newlines + 1;
+}
+async function read_content(file_path) {
+  try {
+    return await readFile(file_path);
+  } catch {
+    return NO_CONTENT;
+  }
+}
+async function untracked_row(root, file) {
+  const lines = line_count(await read_content(path2.join(root, file)));
+  return `${String(lines)}	0	${git_path_quoting.quote(file)}`;
+}
+async function untracked_numstat(root, files) {
+  const rows = await Promise.all(files.map(async (file) => await untracked_row(root, file)));
+  return rows.join(NEWLINE);
+}
+async function read_guide() {
+  const measured = await lane_implement_rate_read.measurements();
+  return split_assess.guide_for(
+    lane_stage_budget.BUDGET_MINUTES.implement,
+    measured.implement_rate,
+    measured.growth
+  );
+}
+async function read_branch() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) throw new Error(UNRESOLVED_BASE);
+  const tracked = await git_command.diff_numstat_since(base);
+  const files = changed_paths.to_paths(await git_command.untracked_names()).map((file) => git_path_quoting.unquote(file));
+  const toplevel = await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const root = toplevel.trim();
+  const numstat = `${tracked}${NEWLINE}${await untracked_numstat(root, files)}`;
+  const adjusted = await split_relocations.without_relocations(root, base, numstat, files);
+  return split_assess.assess(adjusted.numstat, await read_guide(), new Set(adjusted.added));
+}
+var split_measure = { line_count, read_branch };
+
+export {
+  split_measure
+};

package/dist/commands/chunk-YVNYX4UA.js

@@ -0,0 +1,74 @@
+import {
+  guard_remedy
+} from "./chunk-KK7TEL5G.js";
+import {
+  delivered_rules
+} from "./chunk-UC5ZOPKX.js";
+import {
+  hook_context,
+  hook_decision
+} from "./chunk-HXAVYXUS.js";
+import {
+  time_hook_transcript,
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/rule-rewrite.ts
+var REWRITING_RULES = delivered_rules.DELIVERED_RULES.filter(
+  (rule) => guard_remedy.is_rewrite(rule.id) && rule.rewrite !== void 0
+);
+var NOTE_SEPARATOR = "\n\n";
+function read_payload_tail(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload ? transcript_tail.read_tail(
+      time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id)
+    ) : "";
+  } catch {
+    return "";
+  }
+}
+function tail_reader(raw_payload) {
+  const cache = {};
+  return function tail() {
+    cache.tail ??= read_payload_tail(raw_payload);
+    return cache.tail;
+  };
+}
+function fold(name, typed, tail, context) {
+  const folded = { input: typed, notes: [] };
+  for (const rule of REWRITING_RULES) {
+    const input = rule.rewrite?.({ name, input: folded.input }, tail, context);
+    if (input === void 0) {
+      continue;
+    }
+    folded.input = input;
+    folded.notes = [...folded.notes, rule.rewrite_note ?? ""];
+  }
+  return folded;
+}
+function typed_payload(raw_payload) {
+  const fields = json_value.parse_or_undefined(raw_payload);
+  if (!json_value.is_record(fields)) return void 0;
+  const input = fields["tool_input"];
+  return json_value.is_record(input) ? { fields, name: String(fields["tool_name"]), input } : void 0;
+}
+function rewrite(raw_payload, context = hook_context.from_process()) {
+  const typed = delivered_rules.is_enabled() ? typed_payload(raw_payload) : void 0;
+  if (typed === void 0) return void 0;
+  const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload), context);
+  if (notes.length === 0) return void 0;
+  const note = notes.join(NOTE_SEPARATOR);
+  return { payload: JSON.stringify({ ...typed.fields, tool_input: input }), input, note };
+}
+var rule_rewrite = {
+  NOTE_SEPARATOR,
+  rewrite
+};
+
+export {
+  rule_rewrite
+};

package/dist/commands/chunk-Z2GZIWAU.js

@@ -0,0 +1,33 @@
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/carry/run-carry-reclaim.ts
+function reclaimed_owner(carry, owner) {
+  if (owner.session === void 0 || owner.session !== carry.owner_session) {
+    return run_carry_conversation.reclaim_owner(carry, owner);
+  }
+  if (owner.pid === void 0 || carry.is_handed_off === true) return carry;
+  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
+}
+function reclaim_at(target, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return false;
+  const reclaimed = reclaimed_owner(read.carry, owner);
+  if (reclaimed === read.carry) return false;
+  stamp_file.replace_stamp(target, reclaimed);
+  return true;
+}
+async function reclaim_carry(owner) {
+  const directory = await run_carry.repository_directory();
+  return directory !== void 0 && reclaim_at(run_carry.carry_path(directory), owner);
+}
+var run_carry_reclaim = { reclaim_at, reclaim_carry };
+
+export {
+  run_carry_reclaim
+};

package/dist/commands/chunk-Z3XNSXQH.js

@@ -0,0 +1,47 @@
+import {
+  run_hold_cli
+} from "./chunk-IQMMYORJ.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/run/park/run-park-release.ts
+var SUCCESS_EXIT_CODE = 0;
+var RELEASE_FLAG = "--release";
+async function read_worktree_directory() {
+  try {
+    return await run_hold.worktree_directory();
+  } catch {
+    return void 0;
+  }
+}
+async function is_held_by_other_run(issue_number) {
+  const directory = await read_worktree_directory();
+  if (directory === void 0) return false;
+  const read = run_hold.read_hold(run_hold.hold_path(directory));
+  return "hold" in read && !run_hold.is_own_hold(read.hold, issue_number);
+}
+async function release_own(issue_number) {
+  const code = await run_hold_cli.run([RELEASE_FLAG, issue_number]);
+  if (code !== SUCCESS_EXIT_CODE) {
+    console.error(
+      `park ${session_cite.issue(issue_number)} \u2014 parked, but the release failed; re-run: pnpm josh run:release ${issue_number}`
+    );
+  }
+  return code;
+}
+async function release(issue_number) {
+  if (!await is_held_by_other_run(issue_number)) return await release_own(issue_number);
+  console.info(
+    `park ${session_cite.issue(issue_number)} \u2014 release skipped: this tree's hold is another run's`
+  );
+  return SUCCESS_EXIT_CODE;
+}
+var run_park_release = { release };
+
+export {
+  run_park_release
+};

package/dist/commands/chunk-Z4E7V7YJ.js

@@ -0,0 +1,18 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/issue-bug-label.ts
+var BUG_DECLARATION_LINE = issue_body_keys.line("kind", "bug");
+function is_bug_fix(body) {
+  const background = markdown_section.section_lines(body, issue_body_keys.heading("background")).join("\n");
+  return markdown_section.has_unfenced_line(background, BUG_DECLARATION_LINE);
+}
+var issue_bug_label = { BUG_DECLARATION_LINE, is_bug_fix };
+
+export {
+  issue_bug_label
+};

package/dist/commands/chunk-Z7C2O5JC.js

@@ -0,0 +1,299 @@
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/ship/run-ship-detach.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+
+// scripts/run/ship/run-ship-record-wait.ts
+import { setTimeout as sleep } from "node:timers/promises";
+var RECORD_POLL_MS = 25;
+var RECORD_WAIT_ATTEMPTS = 200;
+function is_pending(record) {
+  return record !== void 0 && record.pid === void 0;
+}
+async function ready_record(read) {
+  const ready = await poll.poll_for(
+    () => {
+      const record = read();
+      return is_pending(record) ? void 0 : { record };
+    },
+    { attempts: RECORD_WAIT_ATTEMPTS, interval_ms: RECORD_POLL_MS, sleeper: sleep }
+  );
+  if (ready !== void 0) return ready.record;
+  await sleep(RECORD_POLL_MS);
+  read();
+  return void 0;
+}
+var run_ship_record_wait = { ready_record };
+
+// scripts/run/ship/run-ship-detach.ts
+var LOG_PREFIX = durable_state.PREFIX.SHIP_LOG;
+var PID_PREFIX = "josh-ship-pid-";
+var BODY_PREFIX = "josh-ship-notify-";
+var KEY_SEPARATOR = "-";
+var LOG_SUFFIX = ".log";
+var BODY_SUFFIX = ".txt";
+var PNPM = "pnpm";
+var INLINE_NOTIFY = "--notify-message";
+var FILE_NOTIFY = "--notify-message-file";
+var NOTIFY_VALUE_INDEX = 1;
+var SUPERVISED_KEY = "JOSH_SHIP_SUPERVISED";
+var LAUNCH_ID_KEY = "JOSH_SHIP_LAUNCH_ID";
+var SUPERVISED_VALUE = "1";
+var LAUNCHED = "launched";
+var BUSY = "busy";
+var FAILED = "failed";
+var RESULT_PREFIX = durable_state.PREFIX.SHIP_RESULT;
+var CLAIM_WINDOW_MS = 12e4;
+var ship_record_schema = z.object({
+  pid: z.number().int().positive().optional(),
+  process_start: z.string().optional(),
+  launched_at: z.number().optional(),
+  launcher_pid: z.number().int().positive().optional(),
+  launcher_start: z.string().optional(),
+  launch_id: z.string(),
+  result: z.enum(["success", "failed"]).optional(),
+  stop_invocation: z.string().optional()
+});
+var LAUNCH_MARK = " \xB7 started by process ";
+var HEADER_START = "\n";
+function key(prefix, request) {
+  return stamp_file.stamp_path(`${prefix}${request.number}${KEY_SEPARATOR}`, request.repository);
+}
+function log_path(repository, number) {
+  return durable_state.path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository, LOG_SUFFIX);
+}
+function result_path(repository, number) {
+  return durable_state.path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository);
+}
+function read_record(repository, number) {
+  try {
+    const raw = stamp_file.read_stamp_text(result_path(repository, number));
+    return raw === void 0 ? void 0 : json_value.parse_with(raw, ship_record_schema);
+  } catch {
+    return void 0;
+  }
+}
+function record_launch(request, pid, launch_id) {
+  stamp_file.write_text_stamp(key(PID_PREFIX, request), String(pid));
+  const process_start = process_identity.read_start(pid);
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    pid,
+    launch_id,
+    launched_at: Date.now(),
+    ...process_start !== void 0 && { process_start }
+  });
+}
+function supervisor_environment(launch_id) {
+  return {
+    ...agent_provider.handoff_environment(),
+    [SUPERVISED_KEY]: SUPERVISED_VALUE,
+    [LAUNCH_ID_KEY]: launch_id
+  };
+}
+function is_within_claim_window(record) {
+  return record.launched_at !== void 0 && Date.now() - record.launched_at < CLAIM_WINDOW_MS;
+}
+function has_live_identity(pid, record, read) {
+  if (record.process_start === void 0) {
+    return is_within_claim_window(record) && process_identity.is_live_pid(pid);
+  }
+  return process_identity.is_present_process(pid, record.process_start, read) !== false;
+}
+function result_of(record, read) {
+  if (record.pid === void 0) {
+    const { launcher_pid, launcher_start } = record;
+    const is_launcher = process_identity.is_same_process(launcher_pid, launcher_start, read);
+    return is_launcher === false ? "abnormal" : "running";
+  }
+  if (has_live_identity(record.pid, record, read)) return "running";
+  return record.result ?? "abnormal";
+}
+function read_result(repository, number, read = process_identity.read_start) {
+  const record = read_record(repository, number);
+  return record === void 0 ? void 0 : {
+    launch_id: record.launch_id,
+    launched_at: record.launched_at,
+    result: result_of(record, read),
+    ...record.stop_invocation !== void 0 && { stop_invocation: record.stop_invocation }
+  };
+}
+function current_record(repository, number) {
+  const record = read_record(repository, number);
+  return record?.launch_id === process.env[LAUNCH_ID_KEY] ? record : void 0;
+}
+function running_since(repository, number) {
+  const record = read_record(repository, number);
+  return record !== void 0 && result_of(record, process_identity.read_start) === "running" ? record.launched_at : void 0;
+}
+async function ready_record2(repository, number) {
+  return await run_ship_record_wait.ready_record(() => current_record(repository, number));
+}
+async function update_record(repository, number, fields) {
+  const record = await ready_record2(repository, number);
+  if (record === void 0) return;
+  stamp_file.replace_stamp(result_path(repository, number), { ...record, ...fields });
+}
+async function mark_result(repository, number, code) {
+  await update_record(repository, number, { result: code === 0 ? "success" : "failed" });
+}
+async function mark_stop(repository, number, stop_invocation) {
+  await update_record(repository, number, { stop_invocation });
+}
+async function claim_identity(repository, number) {
+  const own = process_identity.own_fields();
+  if (own.process_start === void 0) return;
+  await update_record(repository, number, own);
+}
+function failed_launch(request, note) {
+  stamp_file.remove_stamp(result_path(request.repository, request.number));
+  return { verdict: FAILED, note };
+}
+function notify_arguments(request) {
+  const [flag, value] = [request.notify[0], request.notify[NOTIFY_VALUE_INDEX]];
+  if (flag !== INLINE_NOTIFY || value === void 0) return request.notify;
+  const body_path = stamp_file.stamp_path(
+    `${BODY_PREFIX}${request.number}${KEY_SEPARATOR}`,
+    request.repository,
+    BODY_SUFFIX
+  );
+  stamp_file.write_text_stamp(body_path, value);
+  return [FILE_NOTIFY, body_path];
+}
+function supervisor_argv(request) {
+  const review = request.is_review ? ["--review"] : [];
+  const cites = request.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    command: PNPM,
+    args: [
+      "josh",
+      "ship",
+      ...review,
+      ...request.unpinned_ok,
+      ...notify_arguments(request),
+      ...request.body,
+      ...cites,
+      request.title
+    ]
+  };
+}
+function prepare_launch(request) {
+  const launch_id = randomUUID();
+  const launcher = process_identity.own_fields();
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    launch_id,
+    launcher_pid: launcher.pid,
+    ...launcher.process_start !== void 0 && { launcher_start: launcher.process_start }
+  });
+  return launch_id;
+}
+function launch(request) {
+  const notes = [];
+  const log = log_path(request.repository, request.number);
+  const launch_id = prepare_launch(request);
+  const result = detached_launch.launch(
+    {
+      argv: supervisor_argv(request),
+      cwd: request.cwd,
+      log_path: log,
+      // The provider travels as a mark because the launch strips the session keys that name it, and
+      // `ship --review` resolves its reviewer from it.
+      env: supervisor_environment(launch_id)
+    },
+    (note) => {
+      notes.push(note);
+    }
+  );
+  agent_provider.warn_of_default();
+  if (result.kind === "failed") return failed_launch(request, result.note);
+  record_launch(request, result.pid, launch_id);
+  return {
+    verdict: LAUNCHED,
+    note: [`supervisor ${String(result.pid)} \u2014 log: ${log}`, ...notes].join("\n")
+  };
+}
+async function detach(request) {
+  if (read_result(request.repository, request.number)?.result === "running") {
+    return {
+      verdict: BUSY,
+      note: `a ship supervisor for ${session_cite.issue(request.number)} is already running`
+    };
+  }
+  const result = launch(request);
+  if (result.verdict === LAUNCHED) {
+    await run_event_stream_emit.emit(
+      run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+      `${issue_cite.plain_for("program", request.number)} ship supervisor launched`
+    );
+  }
+  return result;
+}
+function last_launch(text) {
+  const mark = text.lastIndexOf(LAUNCH_MARK);
+  if (mark === -1) return text;
+  return text.slice(text.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
+}
+function read_log(repository, number) {
+  const text = stamp_file.read_stamp_text(log_path(repository, number));
+  return text === void 0 ? void 0 : last_launch(text);
+}
+function is_supervised(source = process.env) {
+  return source[SUPERVISED_KEY] === SUPERVISED_VALUE;
+}
+var run_ship_detach = {
+  mark_stop,
+  BUSY,
+  FAILED,
+  LAUNCHED,
+  LAUNCH_ID_KEY,
+  claim_identity,
+  mark_result,
+  read_result,
+  SUPERVISED_KEY,
+  detach,
+  is_supervised,
+  last_launch,
+  log_path,
+  read_log,
+  read_record,
+  result_path,
+  running_since,
+  supervisor_argv,
+  supervisor_environment
+};
+
+export {
+  run_ship_detach
+};