@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-FJ622XHY.js

@@ -0,0 +1,179 @@
+import {
+  run_pr_return
+} from "./chunk-7VXSMXVE.js";
+import {
+  run_add
+} from "./chunk-HYVAEK6M.js";
+import {
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  run_event_retry
+} from "./chunk-F7SAHNGR.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  lane_await
+} from "./chunk-YSDBY2G7.js";
+import {
+  run_cut
+} from "./chunk-OTCWA4QE.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  pr_info_schema
+} from "./chunk-34DND4BA.js";
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/run-repair-attempt.ts
+import { statSync } from "node:fs";
+var REPAIR_SUFFIX = " repair";
+var LOCK_WAIT_MS = 5e3;
+var PERMANENT_KINDS = /* @__PURE__ */ new Set(["merge", "withdraw", "split"]);
+var QUEUED_END_KINDS = /* @__PURE__ */ new Set([
+  ...PERMANENT_KINDS,
+  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+  run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+  run_event_stream.EVENT_KIND.PARK
+]);
+var WRITE_FAILED = "Could not record the repair attempt boundary.";
+function repair_text(issue) {
+  return `${run_event_retry.text_of(Number(issue))}${REPAIR_SUFFIX}`;
+}
+function issue_attempt(events, issue) {
+  return run_event_retry.current_attempts(events).filter((event) => run_event_scope.issue_named(event) === issue);
+}
+function is_queued(events, issue) {
+  return events[0]?.text === repair_text(issue) && events.every((event) => !QUEUED_END_KINDS.has(event.kind));
+}
+function reviewed_at(events) {
+  if (events.some((event) => PERMANENT_KINDS.has(event.kind))) return void 0;
+  return events.findLast((event) => event.kind === run_event_stream.EVENT_KIND.HUMAN_REVIEW)?.at;
+}
+async function is_unprotected(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  return read.kind === "state" && read.state.state === "OPEN" && run_add.protected_label(read.state.labels) === void 0;
+}
+async function is_returned(lane, since) {
+  const raw = await git_gh_command.pr_view(lane.branch);
+  if (json_value.parse_with(raw, pr_info_schema)?.state !== "OPEN") return false;
+  if (since === void 0) return true;
+  const returned = await run_pr_return.read(lane.issue, lane.directory);
+  return run_pr_return.comments_since(returned.comments, Date.parse(since)).some((comment) => comment.is_trusted === true);
+}
+function cut_target(lane) {
+  const directory = git_common_directory.own(lane.directory);
+  return directory === void 0 ? void 0 : run_cut.cut_path(directory);
+}
+function can_end_cut(target, lane) {
+  const read = run_cut.read_cut(target);
+  if (read.kind === "none") return true;
+  if (read.kind === "unreadable") return false;
+  return read.cut.issue === lane.issue && read.cut.branch === lane.branch && read.cut.invocation === run_cut.invocation_for(lane.issue);
+}
+async function append_boundary(issue) {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0) throw new Error(WRITE_FAILED);
+  const result = await run_event_stream_emit.append_at(
+    target,
+    run_event_stream.EVENT_KIND.ADD,
+    repair_text(issue),
+    /* @__PURE__ */ new Date()
+  );
+  if (!result.appended) throw new Error(WRITE_FAILED);
+}
+async function has_ended_ship(issue) {
+  const repository = await run_carry.repository_directory();
+  if (repository === void 0) return false;
+  const info = statSync(run_ship_detach.result_path(repository, issue), { throwIfNoEntry: false });
+  if (info === void 0) return true;
+  const result = run_ship_detach.read_result(repository, issue);
+  return result !== void 0 && result.result !== "running";
+}
+async function is_clean(lane) {
+  try {
+    return await git_command.status(lane.directory) === "";
+  } catch {
+    return false;
+  }
+}
+async function is_repairable(issue, lane) {
+  return await is_unprotected(issue) && await is_clean(lane);
+}
+async function ready_lane(issue) {
+  if (await lane_await.other_process_trace(issue) !== "none" || !await has_ended_ship(issue)) {
+    return void 0;
+  }
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0 || !await is_repairable(issue, lane)) return void 0;
+  return lane;
+}
+function eligible_cut_target(lane, expected_target) {
+  const target = cut_target(lane);
+  if (expected_target !== void 0 && expected_target !== target) return void 0;
+  return target !== void 0 && can_end_cut(target, lane) ? target : void 0;
+}
+async function finish(lane, events, since, expected_target) {
+  const target = eligible_cut_target(lane, expected_target);
+  if (target === void 0 || !await is_returned(lane, since)) return false;
+  if (!is_queued(events, lane.issue)) await append_boundary(lane.issue);
+  run_cut.end_cut(target);
+  return true;
+}
+function is_candidate(events, issue) {
+  return reviewed_at(events) !== void 0 || is_queued(events, issue);
+}
+function checked_preparation(is_prepared, events, issue) {
+  if (!is_prepared && is_queued(events, issue)) {
+    throw new Error("Could not safely resume the queued repair.");
+  }
+  return is_prepared;
+}
+async function prepare_held(issue, expected_target) {
+  const events = issue_attempt(await run_event_stream_emit.all_events(true), issue);
+  if (!is_candidate(events, issue)) return false;
+  const lane = await ready_lane(issue);
+  const is_prepared = lane === void 0 ? false : await finish(lane, events, reviewed_at(events), expected_target);
+  return checked_preparation(is_prepared, events, issue);
+}
+async function prepare(issue, expected_target) {
+  const lock = repository_lock.lock_path(`josh-repair-${issue}-`);
+  const is_prepared = await repository_lock.with_lock(
+    async () => await prepare_held(issue, expected_target),
+    lock,
+    LOCK_WAIT_MS
+  );
+  if (is_prepared === void 0) throw new Error("Could not lock the repair attempt.");
+  return is_prepared;
+}
+var run_repair_attempt = { issue_attempt, prepare, reviewed_at };
+
+export {
+  run_repair_attempt
+};

package/dist/commands/chunk-FQPL6T66.js

@@ -0,0 +1,80 @@
+import {
+  direct_importers
+} from "./chunk-7GICNM73.js";
+
+// scripts/test/related-heavy-tests.ts
+import path2 from "node:path";
+
+// scripts/test/unit-durations.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var RECORD_FILE = "tools/test/unit-durations.json";
+function parse(text) {
+  const parsed = JSON.parse(text);
+  if (typeof parsed !== "object" || parsed === null) return {};
+  return Object.fromEntries(
+    Object.entries(parsed).filter(
+      (entry) => typeof entry[1] === "number"
+    )
+  );
+}
+function read(root) {
+  try {
+    return parse(readFileSync(path.join(root, RECORD_FILE), "utf8"));
+  } catch {
+    return {};
+  }
+}
+var unit_durations = {
+  RECORD_FILE,
+  parse,
+  read
+};
+
+// scripts/test/vitest-cli-excludes.ts
+var EXCLUDE_FLAG = "--exclude";
+function cli_excludes(argv) {
+  return argv.slice(1).filter((_argument, index) => argv[index] === EXCLUDE_FLAG);
+}
+var vitest_cli_excludes = { EXCLUDE_FLAG, cli_excludes };
+
+// scripts/test/related-heavy-tests.ts
+var HEAVY_TEST_MS = 1e4;
+var { EXCLUDE_FLAG: EXCLUDE_FLAG2 } = vitest_cli_excludes;
+var TEST_SUFFIX_PATTERN = /(?:\.integration)?\.test$/u;
+var { module_key } = direct_importers;
+function heavy_tests(durations) {
+  return Object.keys(durations).filter((file) => (durations[file] ?? 0) > HEAVY_TEST_MS);
+}
+function imports_directly(file, scoped, reader) {
+  const source = reader.read_source(file);
+  if (source === void 0) return true;
+  return direct_importers.names_any(source, file, scoped, reader.imports);
+}
+function is_kept(file, scoped, reader) {
+  const key = module_key(file);
+  if (scoped.has(key) || scoped.has(key.replace(TEST_SUFFIX_PATTERN, ""))) return true;
+  return imports_directly(file, scoped, reader);
+}
+function excluded_tests(scoped_files, reader) {
+  const scoped = new Set(scoped_files.map((file) => module_key(file)));
+  return heavy_tests(reader.durations).filter((file) => !is_kept(file, scoped, reader));
+}
+function file_reader(root) {
+  return { ...direct_importers.source_reader(root), durations: unit_durations.read(root) };
+}
+function exclude_flags(scope, root, reader = file_reader(root)) {
+  if (scope.mode !== "related") return [];
+  const scoped = scope.files.map((file) => path2.relative(root, file));
+  return excluded_tests(scoped, reader).flatMap((file) => [EXCLUDE_FLAG2, file]);
+}
+var related_heavy_tests = {
+  EXCLUDE_FLAG: EXCLUDE_FLAG2,
+  HEAVY_TEST_MS,
+  exclude_flags,
+  heavy_tests
+};
+
+export {
+  related_heavy_tests
+};

package/dist/commands/chunk-FSM3WPTR.js

@@ -0,0 +1,73 @@
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  removed_tests,
+  test_titles
+} from "./chunk-ISNZX75X.js";
+import {
+  review_code_tree
+} from "./chunk-EKKUHXFD.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/review/removed-tests-check.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var UNREADABLE_MESSAGE = "Merge refused: the change base could not be resolved, so the tests this change removes could not be listed; re-run once `git merge-base` answers.";
+function titles_in(api, texts) {
+  return texts.flatMap((text) => test_titles.titles_of(api, text));
+}
+async function base_texts(base, paths) {
+  const held = await changed_paths.read_held_at(base, paths);
+  return await Promise.all(
+    held.map(async (relative) => await git_command.show_file(`${base}:${relative}`))
+  );
+}
+function tree_texts(root, paths) {
+  return paths.map((relative) => path.join(root, relative)).filter((absolute) => existsSync(absolute)).map((absolute) => readFileSync(absolute, "utf8"));
+}
+function added_titles(before, after) {
+  const held = new Set(before);
+  return after.filter((title) => !held.has(title));
+}
+async function changes() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) return void 0;
+  const root = await git_command.repository_root();
+  const api = review_code_tree.load_typescript(root);
+  if (api === void 0) return { removed: [], added: [] };
+  const changed = await changed_paths.read_changed_since(base);
+  const paths = changed.filter((relative) => test_declared_logic.is_test_file(relative));
+  const before = titles_in(api, await base_texts(base, paths));
+  const after = titles_in(api, tree_texts(root, paths));
+  return { removed: removed_tests.removed(before, after), added: added_titles(before, after) };
+}
+async function read() {
+  const found = await changes();
+  return found?.removed;
+}
+async function body_refusal(pr_body) {
+  const removed = await read();
+  if (removed === void 0) return UNREADABLE_MESSAGE;
+  const left = removed_tests.undisposed(removed, pr_body);
+  return left.length === 0 ? void 0 : removed_tests.refusal_message(left);
+}
+async function refusal(branch_name) {
+  return await body_refusal(await git_gh_command.pr_get_body(branch_name));
+}
+var removed_tests_check = { body_refusal, changes, read, refusal, UNREADABLE_MESSAGE };
+
+export {
+  removed_tests_check
+};

package/dist/commands/chunk-FSZA4DME.js

@@ -0,0 +1,268 @@
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  time_bundle_call
+} from "./chunk-NXWVWI4U.js";
+import {
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  hook_decision,
+  hook_tool_payload
+} from "./chunk-HXAVYXUS.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/bash-revert.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import path2 from "node:path";
+import { z } from "zod";
+
+// scripts/hooks/step-zero-notice.ts
+import { tmpdir } from "node:os";
+import path from "node:path";
+var STAMP_PREFIX = "josh-step-zero-notice-";
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
+var PARENT_PREFIX = "..";
+var NOTICE = "Before writing any implementation code: present the two-layer work summary (Now / Change / Check, then every change with its test) once per Issue. Full rule: Code Change Rules Step 0 in CLAUDE.md.";
+var STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX);
+function edited_paths(tool_input) {
+  if (!json_value.is_record(tool_input)) return [];
+  const { file_path, file_paths } = tool_input;
+  const listed = Array.isArray(file_paths) ? file_paths : [];
+  return [file_path, ...listed].filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+}
+function is_external(relative) {
+  return relative.startsWith(PARENT_PREFIX) || path.isAbsolute(relative);
+}
+function is_scratch_record(file_path, scratch_root = tmpdir()) {
+  const relative = path.relative(scratch_root, file_path);
+  const is_scratch = !is_external(relative);
+  return is_scratch && [".md", ".json", ".txt"].includes(path.extname(file_path));
+}
+function should_skip_external(relative, file_path, should_include_external) {
+  return is_external(relative) && (!should_include_external || is_scratch_record(file_path));
+}
+function is_runtime_file(file_path, root, should_include_external = false) {
+  const relative = path.relative(root, path.resolve(root, file_path));
+  if (is_scratch_record(path.resolve(root, file_path), path.join(root, ".josh/tmp")) || should_skip_external(relative, path.resolve(root, file_path), should_include_external)) {
+    return false;
+  }
+  return !test_declared_logic.is_exempt(relative.split(path.sep).join("/"));
+}
+function is_runtime_edit(raw_payload, root = process.cwd(), should_include_external = false) {
+  const payload = hook_tool_payload.parse(raw_payload);
+  if (payload === void 0 || !EDIT_TOOLS.has(payload.tool_name)) return false;
+  return edited_paths(payload.tool_input).some(
+    (file_path) => is_runtime_file(file_path, root, should_include_external)
+  );
+}
+function is_candidate(raw_payload, root) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload === void 0 || !is_runtime_edit(raw_payload, root)) return void 0;
+  return payload.transcript_path;
+}
+function notice(raw_payload, root = process.cwd()) {
+  const transcript = is_candidate(raw_payload, root);
+  if (transcript === void 0) return void 0;
+  const target = STAMP.path(transcript);
+  if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE;
+}
+var step_zero_notice = {
+  NOTICE,
+  edited_paths,
+  is_runtime_edit,
+  is_runtime_file,
+  notice,
+  stamp_path: STAMP.path
+};
+
+// scripts/hooks/bash-revert.ts
+var STAMP_PREFIX2 = "josh-bash-revert-";
+var UNTRACKED = "??";
+var ABSENT = "absent";
+var STATUS_WIDTH = 3;
+var OPERATIONAL_RECORDS = ".josh/";
+var BACKUP_DIRECTORY = ".josh/tmp/bash-revert";
+var BEFORE_CALL_DIRECTORY = "before-call";
+var STAMP_EXTENSION = ".json";
+var PATH_BREAK = /[^\w./-]+/u;
+var snapshot_schema = z.record(z.string(), z.string());
+var NONE_MOVED = { revert: [], restore: [], keep: [], unknown: [] };
+var HANDOFF = "This shell wrote runtime files; hand implementation to a worker lane.";
+var UNKNOWN_WRITER = "Changed during the call by a writer its command does not name, so left in place:";
+function content_hash(file) {
+  return existsSync(file) ? stamp_file.digest(readFileSync(file)) : ABSENT;
+}
+function dirty_entries(root) {
+  const status = git_spawn_sync.run(
+    ["status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all"],
+    { cwd: root }
+  );
+  const entries = status.exit_code === 0 ? status.stdout.split("\0") : [];
+  return entries.filter((entry) => entry.length > STATUS_WIDTH && !entry.endsWith("/"));
+}
+function is_guarded_file(file, root) {
+  return !file.startsWith(OPERATIONAL_RECORDS) && step_zero_notice.is_runtime_file(file, root);
+}
+function snapshot(root, entries = dirty_entries(root)) {
+  const runtime = entries.map((entry) => entry.slice(STATUS_WIDTH)).filter((file) => is_guarded_file(file, root));
+  return Object.fromEntries(runtime.map((file) => [file, content_hash(path2.join(root, file))]));
+}
+function guarded_call(raw_payload) {
+  if (agent_session_role.can_implement()) return void 0;
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== "Bash") return void 0;
+  return {
+    transcript: payload.transcript_path,
+    command: time_shell.bash_command(payload.tool_input)
+  };
+}
+function copy_into(source, destination) {
+  mkdirSync(path2.dirname(destination), { recursive: true });
+  copyFileSync(source, destination);
+}
+function saved_directory(transcript, root) {
+  const key = path2.basename(stamp_file.stamp_path(STAMP_PREFIX2, transcript), STAMP_EXTENSION);
+  return path2.join(root, BACKUP_DIRECTORY, BEFORE_CALL_DIRECTORY, key);
+}
+function save_dirty(before, root, saved) {
+  rmSync(saved, { recursive: true, force: true });
+  for (const [file, hash] of Object.entries(before)) {
+    if (hash !== ABSENT) copy_into(path2.join(root, file), path2.join(saved, file));
+  }
+}
+function stamp(raw_payload, root = process.cwd()) {
+  const transcript = guarded_call(raw_payload)?.transcript;
+  if (transcript === void 0) return;
+  const target = stamp_file.stamp_path(STAMP_PREFIX2, transcript);
+  try {
+    const before = snapshot(root);
+    stamp_file.write_text_stamp(target, JSON.stringify(before));
+    save_dirty(before, root, saved_directory(transcript, root));
+  } catch {
+  }
+}
+function stamped(transcript) {
+  const text = stamp_file.read_stamp_text(stamp_file.stamp_path(STAMP_PREFIX2, transcript));
+  return text === void 0 ? void 0 : json_value.parse_with(text, snapshot_schema);
+}
+function entry_file(entry) {
+  return entry.slice(STATUS_WIDTH);
+}
+function moved_entries(transcript, root) {
+  const before = stamped(transcript);
+  if (before === void 0) return NONE_MOVED;
+  const entries = dirty_entries(root);
+  const after = snapshot(root, entries);
+  const saved = saved_directory(transcript, root);
+  const dirty = Object.keys(before).filter(
+    (file) => content_hash(path2.join(root, file)) !== before[file]
+  );
+  const intact = dirty.filter((file) => content_hash(path2.join(saved, file)) === before[file]);
+  return {
+    revert: entries.filter((entry) => {
+      const file = entry_file(entry);
+      return Object.hasOwn(after, file) && !Object.hasOwn(before, file);
+    }),
+    restore: intact,
+    keep: dirty.filter((file) => !intact.includes(file)),
+    unknown: []
+  };
+}
+function names(command, file) {
+  if (time_bundle_call.bash_facts(command).is_bundleable) return false;
+  return command.split(PATH_BREAK).some((word) => word === file || word.endsWith(`/${file}`));
+}
+function attributed(moved, command) {
+  const changed = [
+    ...moved.revert.map((entry) => entry_file(entry)),
+    ...moved.restore,
+    ...moved.keep
+  ];
+  return {
+    revert: moved.revert.filter((entry) => names(command, entry_file(entry))),
+    restore: moved.restore.filter((file) => names(command, file)),
+    keep: moved.keep.filter((file) => names(command, file)),
+    unknown: changed.filter((file) => !names(command, file))
+  };
+}
+function restore(file, root) {
+  const restored = git_spawn_sync.run(["checkout", "HEAD", "--", file], { cwd: root });
+  if (restored.exit_code !== 0) git_spawn_sync.run(["rm", "-q", "-f", "--", file], { cwd: root });
+}
+function back_up(file, root, backup) {
+  const source = path2.join(root, file);
+  if (existsSync(source)) copy_into(source, path2.join(backup, file));
+}
+function revert_file(entry, root, backup) {
+  const file = entry_file(entry);
+  back_up(file, root, backup);
+  if (entry.startsWith(UNTRACKED)) rmSync(path2.join(root, file), { force: true });
+  else restore(file, root);
+}
+function restore_saved(file, root, backup, saved) {
+  const copy = path2.join(saved, file);
+  back_up(file, root, backup);
+  if (existsSync(copy)) copy_into(copy, path2.join(root, file));
+  else rmSync(path2.join(root, file), { force: true });
+}
+function put_back(moved, root, backup, saved) {
+  for (const entry of moved.revert) revert_file(entry, root, backup);
+  for (const file of moved.restore) restore_saved(file, root, backup, saved);
+}
+function reason_parts(moved, backup) {
+  const reverted = moved.revert.map((entry) => entry_file(entry));
+  const put_back_files = [...reverted, ...moved.restore];
+  return [
+    [[...put_back_files, ...moved.keep], HANDOFF],
+    [reverted, `Reverted: ${reverted.join(", ")}.`],
+    [moved.restore, `Restored to their content before the call: ${moved.restore.join(", ")}.`],
+    [put_back_files, `Their content before the revert: ${backup}/.`],
+    [moved.keep, `Changed, kept as dirty before the call: ${moved.keep.join(", ")}.`],
+    [moved.unknown, `${UNKNOWN_WRITER} ${moved.unknown.join(", ")}.`]
+  ];
+}
+function block_reason(moved, backup) {
+  return reason_parts(moved, backup).filter(([files]) => files.length > 0).map(([, sentence]) => sentence).join(" ");
+}
+function revert(raw_payload, root = process.cwd()) {
+  const call = guarded_call(raw_payload);
+  if (call === void 0) return void 0;
+  const moved = attributed(moved_entries(call.transcript, root), call.command);
+  const { revert: reverted, restore: restored, keep, unknown } = moved;
+  if ([reverted, restored, keep, unknown].every((files) => files.length === 0)) return void 0;
+  const backup = path2.join(BACKUP_DIRECTORY, (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-"));
+  put_back(moved, root, path2.join(root, backup), saved_directory(call.transcript, root));
+  return JSON.stringify({ decision: "block", reason: block_reason(moved, backup) });
+}
+function is_shell(raw_payload) {
+  return hook_decision.parse_hook_payload(raw_payload)?.tool_name === "Bash";
+}
+function respond(raw_payload) {
+  const envelope = revert(raw_payload);
+  if (envelope !== void 0) process.stdout.write(`${envelope}
+`);
+}
+var bash_revert = { is_shell, respond, revert, stamp };
+
+export {
+  step_zero_notice,
+  bash_revert
+};

package/dist/commands/chunk-FVPRBMHE.js

@@ -0,0 +1,38 @@
+import {
+  git_command,
+  git_diff_reads
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/git/change-base.ts
+async function resolved() {
+  try {
+    return await git_command.change_base_commit();
+  } catch {
+    return void 0;
+  }
+}
+async function incoming_base() {
+  try {
+    const reference = await git_command.default_branch_reference();
+    return await git_spawn.read([...git_diff_reads.incoming_base_arguments(reference)]);
+  } catch {
+    return void 0;
+  }
+}
+async function later_of(base, incoming) {
+  const kept = await git_spawn.read([...git_diff_reads.later_base_arguments(base, incoming)]);
+  return git_diff_reads.later_base_of(kept, base);
+}
+async function resolved_through_merge() {
+  const [base, incoming] = await Promise.all([resolved(), incoming_base()]);
+  if (base === void 0 || incoming === void 0) return base;
+  return await later_of(base, incoming);
+}
+var change_base = { resolved, resolved_through_merge };
+
+export {
+  change_base
+};