@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-RKIAX4DZ.js

@@ -1,191 +0,0 @@
-import {
-  issue_merged
-} from "./chunk-HTIDHEEN.js";
-import {
-  issue_outcome
-} from "./chunk-5CG3XU3O.js";
-import {
-  git_gh_issue_alias_graphql
-} from "./chunk-HWEZRNPL.js";
-import {
-  PAGE,
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  git_gh_etag_read
-} from "./chunk-EWVR5AEX.js";
-import {
-  issue_label_schema
-} from "./chunk-34DND4BA.js";
-import {
-  ALREADY_DONE_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-
-// scripts/run/board/run-board-closed.ts
-import { z as z2 } from "zod";
-
-// scripts/run/board/run-board-closed-graphql.ts
-import { z } from "zod";
-var TIMELINE_TYPES = [
-  "CLOSED_EVENT",
-  "REOPENED_EVENT",
-  "CROSS_REFERENCED_EVENT",
-  "LABELED_EVENT",
-  "UNLABELED_EVENT"
-].join(", ");
-var CLOSED_FIELDS = `title state stateReason closedAt
-	labels(${PAGE}) { nodes { name } }
-	timelineItems(${PAGE}, itemTypes: [${TIMELINE_TYPES}]) {
-		pageInfo { hasNextPage }
-		nodes {
-			type: __typename
-			... on ClosedEvent { stateReason }
-			... on LabeledEvent { label { name } }
-			... on UnlabeledEvent { label { name } }
-			... on CrossReferencedEvent { source { ... on PullRequest { mergedAt } } }
-		}
-	}`;
-var REST_EVENTS = {
-  ClosedEvent: "closed",
-  ReopenedEvent: "reopened",
-  CrossReferencedEvent: "cross-referenced",
-  LabeledEvent: "labeled",
-  UnlabeledEvent: "unlabeled"
-};
-var label_schema = z.object({ name: z.string() });
-var page_info_schema = z.object({ hasNextPage: z.boolean() });
-var event_node_schema = z.object({
-  type: z.string(),
-  stateReason: z.string().nullish(),
-  label: label_schema.nullish(),
-  source: z.object({ mergedAt: z.string().nullish() }).nullish()
-});
-var timeline_schema = z.object({
-  pageInfo: page_info_schema,
-  nodes: z.array(event_node_schema)
-});
-var closed_fields_schema = z.object({
-  title: z.string(),
-  state: z.string(),
-  stateReason: z.string().nullish(),
-  closedAt: z.string().nullish(),
-  labels: z.object({ nodes: z.array(label_schema) }),
-  timelineItems: timeline_schema
-});
-function reason_of(reason) {
-  return reason?.toLowerCase();
-}
-function to_rest_event(node) {
-  return {
-    event: REST_EVENTS[node.type] ?? "",
-    state_reason: reason_of(node.stateReason),
-    label: node.label ?? void 0,
-    source: { issue: { pull_request: { merged_at: node.source?.mergedAt ?? void 0 } } }
-  };
-}
-function is_merged_of(issue) {
-  if (issue.timelineItems.pageInfo.hasNextPage) return void 0;
-  const events = issue.timelineItems.nodes.map((node) => to_rest_event(node));
-  const rows = issue_merged.page_rows(JSON.stringify(events));
-  return rows === void 0 ? void 0 : issue_merged.is_merged_close(rows);
-}
-function to_source(issue) {
-  const view = {
-    title: issue.title,
-    state: issue.state,
-    stateReason: reason_of(issue.stateReason),
-    closedAt: issue.closedAt ?? void 0,
-    labels: issue.labels.nodes
-  };
-  return { json: JSON.stringify(view), is_merged: is_merged_of(issue) };
-}
-async function read_sources(issues) {
-  const read = await git_gh_issue_alias_graphql.read_aliased(
-    issues,
-    CLOSED_FIELDS,
-    closed_fields_schema
-  );
-  return new Map([...read.answers].map(([issue, fields]) => [issue, to_source(fields)]));
-}
-var run_board_closed_graphql = { read_sources };
-
-// scripts/run/board/run-board-closed.ts
-var CLOSED_FIELDS2 = "title,state,stateReason,closedAt,labels";
-var CLOSED_STATE = "CLOSED";
-var NOT_PLANNED_REASON = "not_planned";
-var STILL_OPEN = "open";
-var READ_CONCURRENCY = 4;
-var closed_schema = z2.looseObject({
-  title: z2.string(),
-  state: z2.string(),
-  stateReason: z2.string().nullish(),
-  closedAt: z2.string().nullish(),
-  labels: z2.array(issue_label_schema).default([])
-});
-function closed_ms_of(view) {
-  const closed_ms = Date.parse(view.closedAt ?? "");
-  return Number.isNaN(closed_ms) ? void 0 : closed_ms;
-}
-async function read_view(issue, source) {
-  const json = source?.json ?? await git_gh_issue_read.issue_view_json(
-    String(issue),
-    CLOSED_FIELDS2,
-    void 0,
-    git_gh_etag_read.read
-  );
-  return json === void 0 ? void 0 : parse_json_object_or_undefined(json, closed_schema);
-}
-async function read_merged(issue, source) {
-  return source?.is_merged ?? await issue_merged.read_merge_state(String(issue));
-}
-async function read_closed(issue, source) {
-  const view = await read_view(issue, source);
-  if (view === void 0) return void 0;
-  if (view.state !== CLOSED_STATE) return STILL_OPEN;
-  const is_merged = await read_merged(issue, source);
-  if (is_merged === void 0) return void 0;
-  const labels = view.labels.map((label) => label.name);
-  const is_not_planned = view.stateReason === NOT_PLANNED_REASON;
-  return {
-    title: view.title,
-    labels,
-    closed_ms: closed_ms_of(view),
-    is_merged,
-    is_not_planned,
-    ...await issue_outcome.recorded(issue, is_merged)
-  };
-}
-async function read_all(issues, read = read_closed) {
-  const sources = await run_board_closed_graphql.read_sources(issues);
-  const answers = await bounded_pool.bounded_map(issues, READ_CONCURRENCY, async (issue) => ({
-    issue,
-    answer: await read(issue, sources.get(issue))
-  }));
-  const closed = new Map(
-    answers.flatMap(
-      ({ issue, answer }) => typeof answer === "object" ? [[issue, answer]] : []
-    )
-  );
-  return { closed, is_whole: answers.every(({ answer }) => answer !== void 0) };
-}
-function state_of(closed) {
-  if (closed.is_merged) return "merged";
-  if (closed.is_not_planned) return "withdrawn";
-  return has_label_name(closed.labels, ALREADY_DONE_LABEL) ? "already_done" : "done";
-}
-function is_reopened(issue, closed, listing) {
-  if (listing.open_numbers?.has(issue) !== true) return false;
-  return closed.closed_ms === void 0 || (listing.read_ms ?? -Infinity) > closed.closed_ms;
-}
-var run_board_closed = { STILL_OPEN, is_reopened, read_all, read_closed, state_of };
-
-export {
-  run_board_closed
-};

package/dist/commands/chunk-RLBFEHHC.js

@@ -1,300 +0,0 @@
-import {
-  hook_context
-} from "./chunk-LQXFVZTS.js";
-import {
-  time_hook_transcript,
-  transcript_tail
-} from "./chunk-EMTZAGT5.js";
-import {
-  josh_environment_file
-} from "./chunk-NFKULY26.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// 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_payload_capture,
-  hook_tool_payload,
-  hook_decision
-};