@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-HUCOQ4PI.js

@@ -0,0 +1,161 @@
+import {
+  epic_blocked_by
+} from "./chunk-5DMFMP4V.js";
+import {
+  stash_push_cli
+} from "./chunk-AMQNHTDN.js";
+import {
+  main_merge_guard
+} from "./chunk-LDYDRXOY.js";
+import {
+  run_hold_cli
+} from "./chunk-IQMMYORJ.js";
+import {
+  run_pause_comment
+} from "./chunk-SNXSRNFI.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.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-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.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-HXAVYXUS.js

@@ -0,0 +1,307 @@
+import {
+  time_hook_transcript,
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  josh_environment_file
+} from "./chunk-NFKULY26.js";
+import {
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-context.ts
+function from_process() {
+  return { cwd: process.cwd(), env: process.env, ancestry: lane_reap.own_ancestry };
+}
+var hook_context = { from_process };
+
+// scripts/josh/hook-payload-capture.ts
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var CAPTURE_DIR_KEY = "JOSH_HOOK_CAPTURE_DIR";
+var NO_TOOL = "none";
+var FILE_EXTENSION = ".json";
+var UNSAFE_NAME_CHARACTERS = /[^\w.-]/gu;
+var MAX_ATTEMPTS = 32;
+var tool_schema = z.looseObject({ tool_name: z.string().min(1) });
+function safe_name(name) {
+  return name.replaceAll(UNSAFE_NAME_CHARACTERS, "-");
+}
+function tool_label(raw_payload) {
+  return safe_name(json_value.parse_with(raw_payload, tool_schema)?.tool_name ?? NO_TOOL);
+}
+function write_new(file, raw_payload) {
+  try {
+    writeFileSync(file, raw_payload, { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function write_capture(directory, hook, raw_payload) {
+  const prefix = `${safe_name(hook)}-${tool_label(raw_payload)}-`;
+  const first = readdirSync(directory).filter((name) => name.startsWith(prefix)).length + 1;
+  for (let index = first; index < first + MAX_ATTEMPTS; index += 1) {
+    const file = path.join(directory, `${prefix}${String(index)}${FILE_EXTENSION}`);
+    if (write_new(file, raw_payload)) return file;
+  }
+  return void 0;
+}
+function capture(hook, raw_payload, environment = process.env) {
+  const directory = environment[CAPTURE_DIR_KEY];
+  if (directory === void 0 || directory === "") return void 0;
+  try {
+    mkdirSync(directory, { recursive: true });
+    return write_capture(directory, hook, raw_payload);
+  } catch {
+    return void 0;
+  }
+}
+var hook_payload_capture = { CAPTURE_DIR_KEY, capture };
+
+// scripts/josh/hook-decision.ts
+import { text } from "node:stream/consumers";
+import { z as z3 } from "zod";
+
+// scripts/josh/hook-envelope.ts
+var HOOK_EVENT_NAME = "PreToolUse";
+var DENY_DECISION = "deny";
+var ALLOW_DECISION = "allow";
+function deny_envelope(reason) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      permissionDecision: DENY_DECISION,
+      permissionDecisionReason: reason
+    }
+  });
+}
+function rewrite_envelope(updated_input, context) {
+  return JSON.stringify({
+    systemMessage: context,
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      permissionDecision: ALLOW_DECISION,
+      updatedInput: updated_input,
+      additionalContext: context
+    }
+  });
+}
+function flow_rewrite_envelope(updated_input, context) {
+  return JSON.stringify({
+    systemMessage: context,
+    hookSpecificOutput: {
+      hookEventName: HOOK_EVENT_NAME,
+      updatedInput: updated_input,
+      additionalContext: context
+    }
+  });
+}
+function notice_envelope(notice) {
+  return JSON.stringify({
+    systemMessage: notice,
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
+  });
+}
+var hook_envelope = { deny_envelope, flow_rewrite_envelope, notice_envelope, rewrite_envelope };
+
+// scripts/josh/hook-tool-payload.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  tool_name: z2.string().min(1),
+  tool_input: z2.unknown()
+});
+function parse(raw_payload) {
+  return json_value.parse_with(raw_payload, schema);
+}
+var hook_tool_payload = { parse, schema };
+
+// scripts/josh/hook-decision.ts
+var payload_schema = hook_tool_payload.schema.extend({
+  transcript_path: z3.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: z3.string().nullish(),
+  // The session's model where the harness hands it over (a Codex payload); Claude Code names it on
+  // the transcript's assistant entries instead (`scripts/rules/main-model.ts`).
+  model: z3.string().nullish()
+});
+var refusal_schema = z3.object({ refused_at_ms: z3.number() });
+var NEVER_MS = 0;
+var DISABLED_VALUES = ["off", "0", "false", "no"];
+function is_switch_enabled(key, environment = process.env) {
+  return !DISABLED_VALUES.includes((environment[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) {
+  return json_value.parse_with(raw_payload, payload_schema);
+}
+var { deny_envelope: deny_envelope2, flow_rewrite_envelope: flow_rewrite_envelope2, notice_envelope: notice_envelope2, rewrite_envelope: rewrite_envelope2 } = hook_envelope;
+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 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 (file_reader.is_absent(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;
+  return json_value.parse_with(raw, refusal_schema)?.refused_at_ms ?? 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 path2(transcript_path) {
+    return stamp_file.stamp_path(prefix, transcript_path);
+  }
+  return { path: path2, 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, hook) {
+  const call = { name: payload.tool_name, input: payload.tool_input };
+  if (!parts.spec.is_candidate(call, hook)) return NO_OUTCOME;
+  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+  const tail = transcript_tail.read_tail(transcript);
+  const is_unit = typeof payload.agent_id === "string" && payload.agent_id.length > 0;
+  const run = { transcript, now_ms, model: payload.model ?? void 0, is_unit, context: hook };
+  const context = { ...parts, tail, call, run };
+  const blocked = block_outcome(context);
+  if (!is_clear(blocked)) return blocked;
+  return notify_outcome(context);
+}
+function guard_outcome(parts, raw_payload, now_ms, hook) {
+  const payload = parse_hook_payload(raw_payload);
+  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key, hook.env)) {
+    return NO_OUTCOME;
+  }
+  return guard_reason_for_payload(parts, payload, now_ms, hook);
+}
+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(environment = process.env) {
+    return is_switch_enabled(spec.switch_key, environment);
+  }
+  function outcome(raw_payload, now_ms = Date.now(), hook = hook_context.from_process()) {
+    try {
+      return guard_outcome(parts, raw_payload, now_ms, hook);
+    } catch (error) {
+      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
+    }
+  }
+  function refusal(...call) {
+    return outcome(...call).reason;
+  }
+  return { is_enabled, outcome, refusal, refusal_path: stamp.path };
+}
+function emit_outcome(outcome) {
+  const { reason, notice, fault } = outcome;
+  if (reason !== void 0) process.stdout.write(`${deny_envelope2(reason)}
+`);
+  else if (notice !== void 0) process.stdout.write(`${notice_envelope2(notice)}
+`);
+  else if (fault !== void 0) process.stdout.write(`${notice_envelope2(fault)}
+`);
+}
+function report_no_payload(command) {
+  process.stderr.write(
+    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
+`
+  );
+}
+async function respond_from_stdin(command, respond) {
+  if (process.stdin.isTTY) {
+    report_no_payload(command);
+    return;
+  }
+  const raw_payload = await text(process.stdin);
+  load_environment_file();
+  hook_payload_capture.capture(command, raw_payload);
+  await respond(raw_payload);
+}
+var hook_decision = {
+  DISABLED_VALUES,
+  ENABLED_VALUES,
+  NEVER_MS,
+  create_refusal_stamp,
+  create_transcript_guard,
+  deny_envelope: deny_envelope2,
+  emit_outcome,
+  flow_rewrite_envelope: flow_rewrite_envelope2,
+  is_switch_enabled,
+  is_switch_opt_in,
+  load_environment_file,
+  notice_envelope: notice_envelope2,
+  parse_hook_payload,
+  respond_from_stdin,
+  rewrite_envelope: rewrite_envelope2,
+  stamp_fault
+};
+
+export {
+  hook_context,
+  hook_payload_capture,
+  hook_tool_payload,
+  hook_decision
+};

package/dist/commands/chunk-HXM26K3O.js

@@ -0,0 +1,67 @@
+import {
+  NEEDS_HUMAN_REVIEW_LABEL,
+  PLANNED_LABEL,
+  has_any_label,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/issue/issue-state.ts
+import { z } from "zod";
+var NO_LABELS = "(none)";
+var LABEL_SEPARATOR = ", ";
+var STATE_LABEL = "state: ";
+var LABELS_LABEL = "labels: ";
+var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
+var YES = "yes";
+var NO = "no";
+var ISSUE_LABEL = "issue: ";
+var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
+var label_schema = z.looseObject({ name: z.string() });
+var issue_state_schema = z.looseObject({
+  state: z.string(),
+  labels: label_schema.array().optional()
+});
+function parse_issue_state(json) {
+  try {
+    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
+    if (parsed === void 0) return void 0;
+    const labels = parsed.labels ?? [];
+    return {
+      state: parsed.state,
+      labels: labels.map((label) => label.name),
+      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function format_labels(labels) {
+  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
+}
+function format_issue_state(state) {
+  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
+  return `${STATE_LABEL}${state.state}
+${LABELS_LABEL}${format_labels(state.labels)}
+${human_review}`;
+}
+function format_attributed_issue_state(issue_number, state) {
+  return `${ISSUE_LABEL}${issue_number}
+${format_issue_state(state)}`;
+}
+function is_planned(read) {
+  return read.kind === "state" && has_label_name(read.state.labels, PLANNED_LABEL);
+}
+var issue_state = {
+  is_planned,
+  NO_LABELS,
+  parse_issue_state,
+  format_issue_state,
+  format_attributed_issue_state
+};
+
+export {
+  issue_state
+};