@joshuafolkken/kit 1.872.0

package/dist/hooks/chunk-Q7NZSWQ5.js

@@ -0,0 +1,240 @@
+import {
+  lane_paths,
+  stamp_file,
+  time_density_hook,
+  time_hook_transcript
+} from "./chunk-JFLMH4K5.js";
+import {
+  josh_environment_file
+} from "./chunk-FXAKJKTB.js";
+
+// scripts/josh/hook-decision.ts
+import { z } from "zod";
+var payload_schema = z.object({
+  transcript_path: z.string().min(1),
+  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
+  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
+  // call of the main line, in silence — the failure every other path here is written to avoid.
+  agent_id: z.string().nullish(),
+  tool_name: z.string().min(1),
+  tool_input: z.unknown()
+});
+var refusal_schema = z.object({ refused_at_ms: z.number() });
+var HOOK_EVENT_NAME = "PreToolUse";
+var DENY_DECISION = "deny";
+var NEVER_MS = 0;
+var MISSING_FILE = "ENOENT";
+var DISABLED_VALUES = ["off", "0", "false", "no"];
+function is_switch_enabled(key) {
+  return !DISABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
+}
+var ENABLED_VALUES = ["on", "1", "true", "yes"];
+function is_switch_opt_in(key) {
+  return ENABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
+}
+function parse_hook_payload(raw_payload) {
+  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
+  return parsed.success ? parsed.data : void 0;
+}
+function deny_envelope(reason) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      permissionDecision: DENY_DECISION,
+      permissionDecisionReason: reason
+    }
+  });
+}
+function notice_envelope(notice) {
+  return JSON.stringify({
+    systemMessage: notice,
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
+  });
+}
+function stamp_fault(switch_key) {
+  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
+}
+function is_missing_file(error) {
+  if (!(error instanceof Error) || !("code" in error)) return false;
+  return typeof error.code === "string" && error.code === MISSING_FILE;
+}
+function error_text(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === "string" ? error : "a value that is not an error";
+}
+function fault_notice(switch_key, error) {
+  if (is_missing_file(error)) return void 0;
+  const detail = error_text(error);
+  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
+}
+function last_refusal_ms(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return NEVER_MS;
+  try {
+    return refusal_schema.parse(JSON.parse(raw)).refused_at_ms;
+  } catch {
+    return NEVER_MS;
+  }
+}
+function record_refusal(target, now_ms) {
+  try {
+    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function create_refusal_stamp(prefix) {
+  function path(transcript_path) {
+    return stamp_file.stamp_path(prefix, transcript_path);
+  }
+  return { path, last_ms: last_refusal_ms, record: record_refusal };
+}
+var { load_environment_file } = josh_environment_file;
+var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
+function fire_once(stamp, run, should_fire, switch_key) {
+  const target = stamp.path(run.transcript);
+  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
+  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
+  return { fired: true, fault: void 0 };
+}
+function block_outcome(context) {
+  const { spec, stamp, tail, call, run } = context;
+  const result = fire_once(
+    stamp,
+    run,
+    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
+    spec.switch_key
+  );
+  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
+  return { reason: void 0, notice: void 0, fault: result.fault };
+}
+function notify_outcome(context) {
+  const { spec, notify_stamp, tail, call, run } = context;
+  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
+  const { notify } = spec;
+  const result = fire_once(
+    notify_stamp,
+    run,
+    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
+    spec.switch_key
+  );
+  if (result.fired) return { reason: void 0, notice: notify.text(call, tail), fault: void 0 };
+  return { reason: void 0, notice: void 0, fault: result.fault };
+}
+function is_clear(outcome) {
+  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
+}
+function guard_reason_for_payload(parts, payload, now_ms) {
+  const call = { name: payload.tool_name, input: payload.tool_input };
+  if (!parts.spec.is_candidate(call)) return NO_OUTCOME;
+  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+  const tail = time_density_hook.read_tail(transcript);
+  const context = { ...parts, tail, call, run: { transcript, now_ms } };
+  const blocked = block_outcome(context);
+  if (!is_clear(blocked)) return blocked;
+  return notify_outcome(context);
+}
+function guard_outcome(parts, raw_payload, now_ms) {
+  const payload = parse_hook_payload(raw_payload);
+  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key)) return NO_OUTCOME;
+  return guard_reason_for_payload(parts, payload, now_ms);
+}
+function create_transcript_guard(spec) {
+  const stamp = create_refusal_stamp(spec.prefix);
+  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
+  const parts = { spec, stamp, notify_stamp };
+  function is_enabled() {
+    return is_switch_enabled(spec.switch_key);
+  }
+  function refusal_path(transcript_path) {
+    return stamp.path(transcript_path);
+  }
+  function outcome(raw_payload, now_ms = Date.now()) {
+    try {
+      return guard_outcome(parts, raw_payload, now_ms);
+    } catch (error) {
+      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
+    }
+  }
+  function refusal(raw_payload, now_ms = Date.now()) {
+    return outcome(raw_payload, now_ms).reason;
+  }
+  return { is_enabled, outcome, refusal, refusal_path };
+}
+function emit_outcome(outcome) {
+  const { reason, notice, fault } = outcome;
+  if (reason !== void 0) process.stdout.write(`${deny_envelope(reason)}
+`);
+  else if (notice !== void 0) process.stdout.write(`${notice_envelope(notice)}
+`);
+  else if (fault !== void 0) process.stdout.write(`${notice_envelope(fault)}
+`);
+}
+function write_outcome(raw_payload, outcome) {
+  load_environment_file();
+  emit_outcome(outcome(raw_payload));
+}
+function write_decision(raw_payload, refusal) {
+  write_outcome(raw_payload, (raw) => ({
+    reason: refusal(raw),
+    notice: void 0,
+    fault: void 0
+  }));
+}
+function report_no_payload(command) {
+  process.stderr.write(
+    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
+`
+  );
+}
+var hook_decision = {
+  DISABLED_VALUES,
+  ENABLED_VALUES,
+  NEVER_MS,
+  create_refusal_stamp,
+  create_transcript_guard,
+  deny_envelope,
+  emit_outcome,
+  fault_notice,
+  is_switch_enabled,
+  is_switch_opt_in,
+  load_environment_file,
+  notice_envelope,
+  parse_hook_payload,
+  report_no_payload,
+  stamp_fault,
+  write_decision,
+  write_outcome
+};
+
+// scripts/run/run-issue-number.ts
+var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
+var BAD_ISSUE_MESSAGE = "Not an issue number: ";
+function require_issue_number(issue) {
+  if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
+}
+var run_issue_number = { BAD_ISSUE_MESSAGE, ISSUE_NUMBER_PATTERN, require_issue_number };
+
+// scripts/lane/lane-child-marker.ts
+var KEY = "JOSH_LANE_CHILD";
+function environment_for(issue) {
+  run_issue_number.require_issue_number(issue);
+  return { [KEY]: issue };
+}
+function marked_issue(source = process.env) {
+  const value = source[KEY];
+  if (value === void 0) return void 0;
+  return run_issue_number.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
+}
+function is_child_of(directory, source = process.env) {
+  const marked = marked_issue(source);
+  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
+}
+var lane_child_marker = { KEY, env_for: environment_for, is_child_of, marked_issue };
+
+export {
+  hook_decision,
+  run_issue_number,
+  lane_child_marker
+};