@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-5AZTSESD.js

@@ -0,0 +1,114 @@
+import {
+  backlog_ready,
+  backlog_stalled
+} from "./chunk-7OEBSPPU.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+
+// scripts/backlog/backlog-stalled-detect.ts
+var NO_FREE = 0;
+var NO_READY = 0;
+var NO_AGE = 0;
+function ready_count_of(ready) {
+  return async function() {
+    const issues = await ready.ready_issues();
+    return issues.length;
+  };
+}
+async function real_emit_stall(text) {
+  const { STALL, CHILD_LAUNCH } = run_event_stream.EVENT_KIND;
+  return await run_event_stream_emit.emit_once_since(STALL, text, CHILD_LAUNCH);
+}
+async function read_real_ledger() {
+  const path = await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function real_mark_offerable(is_offerable) {
+  await lane_ledger_write.record_offerable(is_offerable);
+}
+function ports_over(ready) {
+  return {
+    resolve_target: run_event_stream_emit.stream_target,
+    read_events: run_event_stream.read_events,
+    now_ms: () => Date.now(),
+    free_lane_count: ready.free_lane_count,
+    ready_count: ready_count_of(ready),
+    read_ledger: read_real_ledger,
+    mark_offerable: real_mark_offerable,
+    emit_stall: real_emit_stall
+  };
+}
+var DEFAULT_PORTS = ports_over(backlog_ready.DEFAULT_PORTS);
+function ok_reading() {
+  return { ready_count: NO_READY, free_lanes: NO_FREE, waiting_ms: NO_AGE };
+}
+async function read_counts(ports) {
+  const free_lanes = await ports.free_lane_count();
+  if (free_lanes <= NO_FREE) return { ready_count: NO_READY, free_lanes };
+  return { ready_count: await ports.ready_count(), free_lanes };
+}
+function has_both(counts) {
+  return counts.ready_count > NO_READY && counts.free_lanes > NO_FREE;
+}
+async function waiting_ms(ports, entries, clock, is_offerable) {
+  const opened_ms = backlog_stalled.open_offerable_ms(entries, clock.reference_ms);
+  if (is_offerable === (opened_ms !== void 0)) return clock.now_ms - (opened_ms ?? clock.now_ms);
+  await ports.mark_offerable(is_offerable);
+  return NO_AGE;
+}
+async function probe_reading(ports, clock) {
+  const counts = await read_counts(ports);
+  const entries = await ports.read_ledger();
+  const waited = await waiting_ms(ports, entries, clock, has_both(counts));
+  return { ...counts, waiting_ms: waited, hold: backlog_stalled.open_hold(entries) };
+}
+function clock_of(ports, target) {
+  const now_ms = ports.now_ms();
+  const age = backlog_stalled.dispatch_age_ms(ports.read_events(target), now_ms);
+  return age === void 0 ? void 0 : { reference_ms: now_ms - age, now_ms };
+}
+async function gather(ports, threshold_ms) {
+  const target = await ports.resolve_target();
+  if (target === void 0) return void 0;
+  const clock = clock_of(ports, target);
+  if (clock === void 0 || clock.now_ms - clock.reference_ms <= threshold_ms) return ok_reading();
+  return await probe_reading(ports, clock);
+}
+async function observe_offerable(is_offerable, ports = DEFAULT_PORTS) {
+  try {
+    const target = await ports.resolve_target();
+    const clock = target === void 0 ? void 0 : clock_of(ports, target);
+    if (clock !== void 0) await waiting_ms(ports, await ports.read_ledger(), clock, is_offerable);
+  } catch {
+  }
+}
+async function report(ports, reading) {
+  await ports.emit_stall(backlog_stalled.describe(reading));
+}
+async function detect_and_report(ports = DEFAULT_PORTS, threshold_ms = backlog_stalled.STALL_THRESHOLD_MS) {
+  const reading = await gather(ports, threshold_ms);
+  const verdict = backlog_stalled.assess(reading, threshold_ms);
+  if (reading !== void 0 && verdict === backlog_stalled.STALLED) await report(ports, reading);
+  return verdict;
+}
+async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
+  try {
+    await detect_and_report(ports_over(ready));
+  } catch {
+  }
+}
+var backlog_stalled_detect = { detect_and_report, observe_offerable, run_stall_check };
+
+export {
+  backlog_stalled_detect
+};

package/dist/commands/chunk-5FUI2MLY.js

@@ -0,0 +1,89 @@
+import {
+  run_park
+} from "./chunk-BPDNGJXY.js";
+import {
+  bash_triggers
+} from "./chunk-2BC33QPY.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  lane_handoff
+} from "./chunk-BRMJVCP7.js";
+import {
+  NEEDS_DECISION_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
+}
+var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+var COMMAND_NOTIFY_MARKER = "stop notified: a confirmation Telegram was sent by this command";
+function mentions_confirmation_notify(text) {
+  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
+}
+function is_parking_child(directory = process.cwd(), source = process.env) {
+  return lane_child_marker.is_child_of(directory, source) && !lane_handoff.is_handed_off(directory, source);
+}
+function is_unparked_child(directory = process.cwd(), source = process.env) {
+  if (!is_parking_child(directory, source)) return false;
+  const issue = lane_child_marker.marked_issue(source);
+  return issue === void 0 || !run_park.is_parked_sync(issue, directory);
+}
+function is_unparked_stop(command, is_child = is_unparked_child) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_child();
+}
+function is_unparked_stop_in(command, context) {
+  return is_unparked_stop(command, () => is_unparked_child(context.cwd, context.env));
+}
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+var PARK_COMMANDS = /* @__PURE__ */ new Set(["run:park"]);
+var CLEAR_FLAG = /(?:^|\s)--clear\b/u;
+function is_park_command(segment) {
+  return shell_segments.is_josh_command(segment, PARK_COMMANDS) && !CLEAR_FLAG.test(segment);
+}
+function records_the_park(command) {
+  if (APPLIES_NEEDS_DECISION.test(command)) return true;
+  return shell_segments.segments_of(command).some((segment) => is_park_command(segment));
+}
+var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `pnpm josh run:park <N> --body-file <path>` (options, tiers, recommendation, stash \u2014 it applies `needs-decision`); a `needs-human-review` / `already-done` stop already is. The park is the stop: no notify after it. Refused once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
+var ROW = {
+  id: "lane-park",
+  is_trigger: bash_triggers.on_bash_command(is_unparked_stop_in),
+  reason: LANE_PARK_REASON,
+  keeps: bash_triggers.on_bash_command(records_the_park),
+  about: {
+    title: "Lane child park",
+    topic: "`.claude/skills/workflow-commands/pre-gate-cut.md`",
+    fires: "a dispatched lane child issuing `pnpm josh notify --task-type confirmation`",
+    quiet: "not a lane child, or not a stop notification"
+  }
+};
+var lane_park = {
+  COMMAND_NOTIFY_MARKER,
+  LANE_PARK_REASON,
+  ROW,
+  is_confirmation_notify,
+  is_parking_child,
+  is_unparked_child,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+export {
+  lane_park
+};

package/dist/commands/chunk-5GI5GLC4.js

@@ -0,0 +1,214 @@
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  COMMAND_TIMEOUT_MS,
+  FETCH_TIMEOUT_MS,
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/version/release-age.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import semver from "semver";
+import { z } from "zod";
+var NO_QUARANTINE_MINUTES = 0;
+var WORKSPACE_PATH = "pnpm-workspace.yaml";
+var workspace_age_schema = z.object({ minimumReleaseAge: z.number().int().nonnegative() });
+var release_times_schema = z.record(z.string(), z.string());
+function parse_workspace(workspace_content) {
+  try {
+    return yaml_document.parse_yaml(workspace_content);
+  } catch {
+    return void 0;
+  }
+}
+function parse_declared_minimum_release_age(workspace_content) {
+  const parsed = workspace_age_schema.safeParse(parse_workspace(workspace_content));
+  return parsed.success ? parsed.data.minimumReleaseAge : void 0;
+}
+function parse_minimum_release_age(workspace_content) {
+  return parse_declared_minimum_release_age(workspace_content) ?? NO_QUARANTINE_MINUTES;
+}
+function is_on_major(version, major) {
+  return major === void 0 || String(semver.major(version)) === major;
+}
+function is_eligible(version, published_at, major, cutoff_ms) {
+  if (semver.valid(version) === null || semver.prerelease(version) !== null || !is_on_major(version, major)) {
+    return false;
+  }
+  const published_ms = Date.parse(published_at);
+  return Number.isFinite(published_ms) && published_ms <= cutoff_ms;
+}
+function select_aged_version(times, major, minimum_age_minutes, now_ms) {
+  const cutoff_ms = now_ms - minimum_age_minutes * MS_PER_MINUTE;
+  const eligible = Object.entries(times).filter(([version, published_at]) => is_eligible(version, published_at, major, cutoff_ms)).map(([version]) => version).toSorted(semver.rcompare);
+  return eligible[0];
+}
+function read_declared_minimum_release_age(workspace_path) {
+  try {
+    return parse_declared_minimum_release_age(readFileSync(workspace_path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function read_minimum_release_age(workspace_path = WORKSPACE_PATH) {
+  return read_declared_minimum_release_age(workspace_path) ?? NO_QUARANTINE_MINUTES;
+}
+function find_declared_minimum_release_age(start, boundary) {
+  const declared = read_declared_minimum_release_age(path.join(start, WORKSPACE_PATH));
+  if (declared !== void 0) return declared;
+  if (start === boundary) return void 0;
+  const parent = path.dirname(start);
+  return parent === start ? void 0 : find_declared_minimum_release_age(parent, boundary);
+}
+function read_nearest_minimum_release_age(start, boundary) {
+  return find_declared_minimum_release_age(path.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
+}
+var release_age = {
+  release_times_schema,
+  parse_minimum_release_age,
+  parse_declared_minimum_release_age,
+  read_minimum_release_age,
+  read_nearest_minimum_release_age,
+  select_aged_version
+};
+
+// scripts/version/npm-registry.ts
+import { execaSync } from "execa";
+import semver2 from "semver";
+import { z as z2 } from "zod";
+var PUBLIC_REGISTRY = "https://registry.npmjs.org";
+var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
+var FULL_ACCEPT = "application/json";
+var SCOPE_SEPARATOR = "/";
+var ENCODED_SCOPE_SEPARATOR = "%2f";
+var SCOPE_PATTERN = /^@[^/]+(?=\/)/u;
+var SCOPE_REGISTRY_SUFFIX = ":registry";
+var GITHUB_REGISTRY_HOST = "npm.pkg.github.com";
+var PNPM = "pnpm";
+var JSON_FLAG = "--json";
+var FAILURE_EXIT_CODE = 1;
+var github_scopes = /* @__PURE__ */ new Map();
+var FETCH_SCRIPT = [
+  "const [url, accept] = process.argv.slice(1)",
+  "const response = await fetch(url, { headers: { accept } })",
+  "if (!response.ok) { console.error(`HTTP ${response.status}`); process.exit(1) }",
+  "process.stdout.write(await response.text())"
+].join("\n");
+var version_schema = z2.string().refine((value) => semver2.valid(value) === value);
+var latest_schema = z2.looseObject({ "dist-tags": z2.looseObject({ latest: version_schema }) });
+var public_version_schema = z2.looseObject({
+  name: z2.string(),
+  version: version_schema,
+  dist: z2.looseObject({ tarball: z2.url(), integrity: z2.string() })
+});
+var times_schema = z2.looseObject({ time: release_age.release_times_schema });
+var name_schema = z2.looseObject({ name: z2.string().optional() });
+var PUBLISHING_SCOPE = "@joshuafolkken/";
+function packument_url(package_name) {
+  return `${PUBLIC_REGISTRY}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
+}
+function read_packument(package_name, accept, should_require = false, version) {
+  const base = packument_url(package_name);
+  const url = version === void 0 ? base : `${base}/${version}`;
+  const result = execaSync(
+    process.execPath,
+    ["--input-type=module", "-e", FETCH_SCRIPT, url, accept],
+    { reject: false, timeout: FETCH_TIMEOUT_MS }
+  );
+  if (result.exitCode !== 0) {
+    if (should_require) {
+      throw new Error(`Public npm request failed: ${package_name}: ${result.stderr}`);
+    }
+    return void 0;
+  }
+  return json_value.parse_or_undefined(result.stdout);
+}
+function is_github_registry(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname === GITHUB_REGISTRY_HOST;
+  } catch {
+    return false;
+  }
+}
+function is_github_scope(scope) {
+  const is_cached_github = github_scopes.get(scope);
+  if (is_cached_github !== void 0) return is_cached_github;
+  const result = execaSync(PNPM, ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
+    reject: false,
+    timeout: FETCH_TIMEOUT_MS
+  });
+  const is_github = result.exitCode === 0 && is_github_registry(result.stdout.trim());
+  github_scopes.set(scope, is_github);
+  return is_github;
+}
+function is_public_source(package_name) {
+  if (package_name === KIT_PACKAGE_NAME) return true;
+  const scope = SCOPE_PATTERN.exec(package_name)?.[0];
+  return scope === void 0 || !is_github_scope(scope);
+}
+function read_latest(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = latest_schema.safeParse(read_packument(package_name, ABBREVIATED_ACCEPT));
+  return parsed.success ? parsed.data["dist-tags"].latest : void 0;
+}
+function read_release_times(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
+  return parsed.success ? parsed.data.time : void 0;
+}
+function has_public_version(package_name, version) {
+  const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
+  return parsed.success && parsed.data.time[version] !== void 0;
+}
+function read_public_version(package_name, version) {
+  if (!version_schema.safeParse(version).success) return void 0;
+  const selected = public_version_schema.safeParse(
+    read_packument(package_name, FULL_ACCEPT, true, version)
+  );
+  if (!selected.success) return void 0;
+  const entry = selected.data;
+  return entry.name === package_name && entry.version === version ? entry : void 0;
+}
+function published_package_name(cwd) {
+  const name = package_manifest.read_manifest_if_valid(cwd, name_schema)?.name;
+  if (name?.startsWith(PUBLISHING_SCOPE) !== true) return void 0;
+  return latest_schema.safeParse(read_packument(name, ABBREVIATED_ACCEPT)).success ? name : void 0;
+}
+function view(spec, field, format = "text") {
+  const format_arguments = format === "json" ? [JSON_FLAG] : [];
+  const result = execaSync(PNPM, ["view", spec, field, ...format_arguments], {
+    reject: false,
+    timeout: COMMAND_TIMEOUT_MS
+  });
+  return { exit_code: result.exitCode ?? FAILURE_EXIT_CODE, stdout: result.stdout };
+}
+function valid_version(value) {
+  return version_schema.safeParse(value).success ? value : void 0;
+}
+var npm_registry = {
+  has_public_version,
+  packument_url,
+  published_package_name,
+  read_latest,
+  read_public_version,
+  read_release_times,
+  valid_version,
+  view
+};
+
+export {
+  release_age,
+  npm_registry
+};