@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-TGCIRQG5.js

@@ -0,0 +1,109 @@
+import {
+  review_round2
+} from "./chunk-OBMXXG5D.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_code_tree
+} from "./chunk-EKKUHXFD.js";
+import {
+  review_attest
+} from "./chunk-37RULO76.js";
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+
+// scripts/review/review-interaction.ts
+var TARGET_DIRECTORIES = ["scripts/run/", "scripts/lane/", "scripts/backlog/", "scripts/hooks/"];
+var NOT_DUE_LINE = "Interaction review not due: this is not the kit repository, or the change touches none of scripts/run/, scripts/lane/, scripts/backlog/ or scripts/hooks/.";
+var QUESTIONS = [
+  "1. Every state, command, label, file or process this change adds or gives a new meaning to \u2014 who else reads or writes it? Search the repository outside the diff for each. Where the plan has a `### \u5F71\u97FF\u3092\u53D7\u3051\u308B\u65E2\u5B58\u306E\u5229\u7528\u8005` section, check it names them all.",
+  "2. Does each of those readers and writers still behave correctly when the new state or value reaches it (for example, a paused lane counted as running)?",
+  "3. Does the change add heavy or synchronous work to a path called repeatedly \u2014 every second, every Bash call, every edit?"
+];
+var ROLE_LINES = [
+  "## Interaction review",
+  "This pass is not a second `/code-review`: do not hunt for bugs inside the diff \u2014 the round before it did. Your role is to find three existing features this change breaks. Check only these three:",
+  ...QUESTIONS,
+  "Report each break with the reader's `file:line` and the change's, rated by the rubric's severities; it is disposed of by `prompts/review.md` \u2192 \"Interaction review\"."
+];
+var INERT_LINE_PREFIX = "Interaction review not due: every run-tooling path this change touches leaves what executes unchanged (round 2\u2019s inert reading \u2014 in these directories, an edit to comments or import specifiers only)";
+var NOT_REQUIRED = "not-required";
+function due_paths(paths, checkout = process.cwd()) {
+  if (!project_checks.is_kit_repository(checkout)) return [];
+  return paths.filter((file) => TARGET_DIRECTORIES.some((directory) => file.startsWith(directory)));
+}
+function brief_block(targets) {
+  const listed = targets.map((file) => `- ${file}`);
+  return [...ROLE_LINES, "Changed in the run tooling:", ...listed].join("\n");
+}
+async function inert_line(due) {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) return void 0;
+  const inert = await review_code_tree.inert_since(base, due);
+  const is_inert = due.every((relative) => review_round2.is_unexecuted(relative, inert));
+  return is_inert ? `${INERT_LINE_PREFIX}: ${due.join(", ")}` : void 0;
+}
+async function unrecorded_reading(due) {
+  const line = await inert_line(due);
+  return line === void 0 ? { status: "missing" } : { status: NOT_REQUIRED, inert_line: line };
+}
+async function reading_of(issue, paths, root = observation_ledger_home.ledger_root()) {
+  const due = due_paths(paths);
+  const content = due.length > 0 ? await observation_ledger_home.read(root) : void 0;
+  if (content === void 0) return { status: NOT_REQUIRED };
+  if (review_finding_ledger.has_issue_record(content, issue, "interaction")) return { status: "ok" };
+  return await unrecorded_reading(due);
+}
+async function status_of(issue, paths, root) {
+  const answer = await reading_of(issue, paths, root);
+  return answer.status;
+}
+async function reading(issue, root) {
+  return await reading_of(issue, await changed_paths.read_changed_paths(false), root);
+}
+async function status(issue, root) {
+  const answer = await reading(issue, root);
+  return answer.status;
+}
+function round_one_slots(answer) {
+  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
+  return answer === "missing" ? [CODE, INTERACTION] : [CODE];
+}
+var MISSING_REASON = "This change touches the run tooling, and no interaction review is recorded for its issue \u2014 the pass that looks for the existing features a change breaks, which `/code-review` does not (joshuafolkken/kit#4276).";
+var REMEDY = "Run it from `pnpm josh review:brief --interaction`, whose reviewer writes its findings with `pnpm josh review:submit --interaction`; record them with `pnpm josh review:record --from-slot --interaction --issue <N> [<n>=<disposition> ...]` and reissue the merge.";
+function refusal_message(issue) {
+  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
+}
+async function refusal(issue, root) {
+  return await status(issue, root) === "missing" ? refusal_message(issue) : void 0;
+}
+var review_interaction = {
+  brief_block,
+  due_paths,
+  NOT_DUE_LINE,
+  QUESTIONS,
+  reading,
+  refusal,
+  refusal_message,
+  round_one_slots,
+  status,
+  status_of
+};
+
+export {
+  review_interaction
+};

package/dist/commands/chunk-TJAGKUS2.js

@@ -0,0 +1,84 @@
+import {
+  backlog_next
+} from "./chunk-SNXSRNFI.js";
+import {
+  backlog_wait_cause
+} from "./chunk-YSBLGTDZ.js";
+import {
+  josh_command
+} from "./chunk-72LAYP5S.js";
+import {
+  shared_cache
+} from "./chunk-RW7OILP7.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+
+// scripts/backlog/backlog-next-shared.ts
+import { z } from "zod";
+var SUCCESS_EXIT_CODE = 0;
+var NEXT_CACHE = { prefix: "josh-backlog-next-", ttl_ms: 6e4 };
+var result_schema = z.object({
+  code: z.number(),
+  out: z.string(),
+  err: z.string().exactOptional()
+});
+async function stream_key(scope) {
+  const target = await run_event_stream_emit.stream_target();
+  const last = target === void 0 ? void 0 : run_event_stream.read_last(target);
+  return JSON.stringify({ argv: scope, last });
+}
+function is_kept(result) {
+  if (result.code !== SUCCESS_EXIT_CODE) return false;
+  return !result.out.split("\n").includes(backlog_next.VERDICT_TOKENS.retry);
+}
+function edge_of(result) {
+  const [token = ""] = result.out.split("\n", 1);
+  const { error, retry, wait, stop, triage } = backlog_next.VERDICT_TOKENS;
+  const is_failed = [error, retry].includes(token);
+  if (is_failed || result.code !== SUCCESS_EXIT_CODE) return "failed";
+  return [wait, stop, triage].includes(token) ? "waiting" : "done";
+}
+function replay(result, should_forward_stderr) {
+  if (should_forward_stderr && result.err !== void 0 && result.err !== "") {
+    console.error(result.err);
+  }
+  return result;
+}
+function wait_deadline(kept) {
+  if (kept?.out.trim() !== backlog_next.VERDICT_TOKENS.wait) return void 0;
+  return backlog_wait_cause.parse(kept.err ?? "").not_before_ms;
+}
+function kept_until(key, now_ms) {
+  const kept = shared_cache.read(NEXT_CACHE, key, result_schema, now_ms);
+  const deadline = wait_deadline(kept);
+  if (deadline !== void 0) return deadline > now_ms ? kept : void 0;
+  return kept;
+}
+async function read(argv, should_forward_stderr = false, timeout_ms) {
+  const key = await stream_key(argv);
+  const now_ms = Date.now();
+  const kept = kept_until(key, now_ms);
+  if (kept !== void 0) return replay(kept, should_forward_stderr);
+  const result = await run_startup.phase(
+    "candidate cache fill",
+    async () => {
+      run_startup.metric("cache", "fill", `${NEXT_CACHE.prefix}:${key}`);
+      return await josh_command.josh_run(argv, should_forward_stderr, timeout_ms);
+    },
+    { edge_of }
+  );
+  if (is_kept(result)) shared_cache.write(NEXT_CACHE, key, result, now_ms);
+  return result;
+}
+var backlog_next_shared = { NEXT_CACHE, edge_of, read, stream_key };
+
+export {
+  backlog_next_shared
+};

package/dist/commands/chunk-TKRUZZXG.js

@@ -0,0 +1,103 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+
+// scripts/lane/lane-early-push-count.ts
+var MULTI_SLOT_EARLY_PUSH = "multi-slot-early-push";
+var PUSHED = "pushed";
+var MULTI_SLOT_MINIMUM = 2;
+function multi_slot_pushed(entries) {
+  return entries.filter(
+    (entry) => entry.kind === "early-push" && entry.result === PUSHED && (entry.slots ?? 0) >= MULTI_SLOT_MINIMUM
+  ).length;
+}
+var lane_early_push_count = { MULTI_SLOT_EARLY_PUSH, multi_slot_pushed };
+
+// scripts/issue/issue-observation-gate.ts
+var PREFIX = "<!-- josh:observation-wait";
+var DECLARATION = /^<!-- josh:observation-wait:v1 (?<url>https:\/\/github\.com\/(?<repo>[\w.-]+\/[\w.-]+)\/issues\/[1-9]\d*#issuecomment-(?<comment>[1-9]\d*)) (?<keys>[\w-]+(?:,[\w-]+)*) -->$/u;
+var LEDGER = / ledger:(?<metric>[\w-]+)>=(?<minimum>[1-9]\d*)(?= -->$)/u;
+var METRICS = /* @__PURE__ */ new Set([lane_early_push_count.MULTI_SLOT_EARLY_PUSH]);
+var EVIDENCE_HEADING = "## Observation evidence";
+var TASK = /^- \[(?<checked>[ xX])\] (?<key>[\w-]+): (?<description>.+)$/u;
+var EVIDENCE = /\[evidence\]\(https:\/\/github\.com\/[\w./#?=&%-]+\)$/u;
+var records = /* @__PURE__ */ new Map();
+var samples = /* @__PURE__ */ new Map();
+function is_evidenced(task) {
+  return task?.["checked"]?.toLowerCase() === "x" && EVIDENCE.test(task["description"] ?? "");
+}
+function declarations(body = "") {
+  return markdown_section.unfenced_lines(body).filter((line) => line.trimStart().startsWith(PREFIX));
+}
+function ledger_of(line) {
+  const groups = LEDGER.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  return { metric: String(groups["metric"]), minimum: Number(groups["minimum"]) };
+}
+function is_known(ledger) {
+  return ledger === void 0 || METRICS.has(ledger.metric);
+}
+function source_of(line) {
+  const trimmed = line.trim();
+  const ledger = ledger_of(trimmed);
+  if (!is_known(ledger)) return void 0;
+  const groups = DECLARATION.exec(trimmed.replace(LEDGER, ""))?.groups;
+  if (groups === void 0) return void 0;
+  return {
+    url: String(groups["url"]),
+    repo: String(groups["repo"]),
+    comment: String(groups["comment"]),
+    keys: String(groups["keys"]).split(","),
+    ledger
+  };
+}
+function is_sampled(ledger) {
+  if (ledger === void 0) return false;
+  return (samples.get(ledger.metric) ?? 0) >= ledger.minimum;
+}
+function sources(bodies) {
+  return bodies.flatMap((body) => declarations(body).flatMap((line) => source_of(line) ?? []));
+}
+function pending(source, body) {
+  const lines = markdown_section.section_lines(body, EVIDENCE_HEADING).join("\n");
+  const tasks = markdown_section.unfenced_lines(lines).map((line) => TASK.exec(line)?.groups);
+  return source.keys.filter((key) => {
+    const matches = tasks.filter((task2) => task2?.["key"] === key);
+    const [task] = matches;
+    return matches.length !== 1 || !is_evidenced(task);
+  });
+}
+function wait_for(line) {
+  const source = source_of(line);
+  if (source === void 0) {
+    return {
+      reason: "unknown observation condition; record a v1 evidence comment and required keys"
+    };
+  }
+  if (is_sampled(source.ledger)) return void 0;
+  const body = records.get(source.url);
+  if (body === void 0) {
+    return { reason: `observation evidence unread: ${source.keys.join(", ")}`, url: source.url };
+  }
+  const missing = pending(source, body);
+  return missing.length === 0 ? void 0 : { reason: `observation evidence required: ${missing.join(", ")}`, url: source.url };
+}
+function wait_of(body) {
+  return declarations(body).map((line) => wait_for(line)).find((wait) => wait !== void 0);
+}
+function record(url, body) {
+  records.set(url, body);
+}
+function record_sample(metric, count) {
+  samples.set(metric, count);
+}
+function reset() {
+  records.clear();
+  samples.clear();
+}
+var issue_observation_gate = { sources, wait_of, record, record_sample, reset };
+
+export {
+  lane_early_push_count,
+  issue_observation_gate
+};

package/dist/commands/chunk-TLCFZAL4.js

@@ -0,0 +1,63 @@
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  stamp_record
+} from "./chunk-NQ4D2XZY.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/park/run-park.ts
+import { z } from "zod";
+var PARK_PREFIX = "josh-run-park-";
+var PARK_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
+var run_park_schema = z.object({
+  issue: z.string(),
+  parked_at: z.string()
+});
+function parse_park(raw) {
+  return json_value.parse_with(raw, run_park_schema);
+}
+function parked_at_of(park) {
+  return park.parked_at;
+}
+var PARK_SPEC = {
+  parse: parse_park,
+  timestamp_of: parked_at_of,
+  max_age_ms: PARK_MAX_AGE_MS
+};
+function park_path(repository, issue) {
+  return stamp_file.stamp_path(`${PARK_PREFIX}${issue}-`, repository);
+}
+function record(issue, directory, now = /* @__PURE__ */ new Date()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  stamp_file.replace_stamp(park_path(repository, issue), { issue, parked_at: now.toISOString() });
+  return true;
+}
+function clear(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository !== void 0) stamp_file.remove_stamp(park_path(repository, issue));
+}
+function is_parked_sync(issue, directory, now = /* @__PURE__ */ new Date()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  const read = stamp_record.classify(
+    stamp_file.read_stamp_text(park_path(repository, issue)),
+    PARK_SPEC,
+    now
+  );
+  return read.kind === "carried" && read.record.issue === issue;
+}
+var run_park = { PARK_MAX_AGE_MS, clear, is_parked_sync, record };
+
+export {
+  run_park
+};