@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-QCRUPRQ2.js

@@ -0,0 +1,207 @@
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/wake/run-wake.ts
+import { z } from "zod";
+var WAKE_PREFIX = "josh-run-wake-";
+var WAKE_LOG_PREFIX = durable_state.PREFIX.WAKE_LOG;
+var WAKE_LOG_SUFFIX = ".log";
+var WAKE_GRACE_MS = 6e5;
+var MAX_WAKE_ATTEMPTS = 3;
+var IDLE_CEILING_MS = backlog_budget.DEFAULT_IDLE_MS;
+var NO_WAKES = 0;
+var ONE_WAKE = 1;
+var WAKE_DECISION = { kind: "wake" };
+var IDLE_DECISION = { kind: "idle" };
+var WAIT_DECISION = { kind: "wait" };
+var PENDING_DECISION = { kind: "pending" };
+var FAILED_DECISION = { kind: "failed" };
+var STOP_REASONS = {
+  none: "ended",
+  unreadable: "unreadable"
+};
+var run_wake_schema = process_owner_schema.extend({
+  invocation: z.string(),
+  started_at: z.string(),
+  woke: z.number(),
+  woke_at: z.string().optional(),
+  launch_at: z.string().optional(),
+  // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
+  attempts: z.number().optional(),
+  woke_pid: z.number().optional(),
+  spawned: z.array(z.string()).optional(),
+  idle_since: z.string().optional(),
+  profile: agent_profile_schema.PROFILE_SCHEMA.optional()
+});
+function is_overdue(marked_at, now, limit_ms = WAKE_GRACE_MS) {
+  const marked = Date.parse(marked_at);
+  if (Number.isNaN(marked)) return true;
+  return now.getTime() - marked > limit_ms;
+}
+function launch_or_idle(input) {
+  if (input.has_work !== false) return WAKE_DECISION;
+  if (input.idle_since === void 0) return IDLE_DECISION;
+  return is_overdue(input.idle_since, input.now, IDLE_CEILING_MS) ? WAKE_DECISION : IDLE_DECISION;
+}
+function decide_launch(input) {
+  if (input.woke_at === void 0) return launch_or_idle(input);
+  if (!is_overdue(input.woke_at, input.now)) return PENDING_DECISION;
+  return input.attempts < MAX_WAKE_ATTEMPTS ? launch_or_idle(input) : FAILED_DECISION;
+}
+function decide_not_handed_off(input) {
+  if (input.is_owner_live) return WAIT_DECISION;
+  return decide_launch(input);
+}
+function decide(input) {
+  if (input.read.kind !== "carried") return { kind: "stop", reason: STOP_REASONS[input.read.kind] };
+  if (input.read.carry.is_handed_off !== true) return decide_not_handed_off(input);
+  return decide_launch(input);
+}
+function wake_path(git_directory) {
+  return stamp_file.stamp_path(WAKE_PREFIX, git_directory);
+}
+function wake_log_path(git_directory) {
+  return durable_state.path(WAKE_LOG_PREFIX, git_directory, WAKE_LOG_SUFFIX);
+}
+function parse_wake(raw) {
+  return json_value.parse_with(raw, run_wake_schema);
+}
+function read_wake(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_wake(raw);
+}
+function write_wake(target, wake) {
+  stamp_file.write_stamp(target, wake);
+}
+function remove_wake(target) {
+  stamp_file.remove_stamp(target);
+}
+function fresh_wake(invocation, now, profile) {
+  return {
+    invocation,
+    ...profile && { profile },
+    started_at: now.toISOString(),
+    woke: NO_WAKES,
+    ...process_identity.own_fields()
+  };
+}
+function is_supervisor_live(wake) {
+  return process_identity.is_same_process(wake.pid, wake.process_start) !== false;
+}
+function carried_state(existing, invocation) {
+  if (existing?.invocation !== invocation) return { woke: NO_WAKES };
+  return {
+    woke: existing.woke,
+    woke_at: existing.woke_at,
+    launch_at: existing.launch_at,
+    attempts: existing.attempts,
+    woke_pid: existing.woke_pid,
+    spawned: existing.spawned,
+    idle_since: existing.idle_since,
+    ...existing.profile && { profile: existing.profile }
+  };
+}
+function is_held_by_live_supervisor(existing) {
+  return existing !== void 0 && is_supervisor_live(existing);
+}
+function reclaim(target, wake) {
+  if (is_held_by_live_supervisor(read_wake(target))) return void 0;
+  remove_wake(target);
+  return stamp_file.create_stamp(target, wake) ? wake : void 0;
+}
+function claim(target, invocation, now, profile) {
+  const existing = read_wake(target);
+  if (is_held_by_live_supervisor(existing)) return void 0;
+  const wake = { ...fresh_wake(invocation, now, profile), ...carried_state(existing, invocation) };
+  return stamp_file.create_stamp(target, wake) ? wake : reclaim(target, wake);
+}
+function count_wake(wake, now, pid, session_id) {
+  const attempts = (wake.attempts ?? NO_WAKES) + ONE_WAKE;
+  const spawned = [...wake.spawned ?? [], session_id];
+  const woke_at = now.toISOString();
+  return {
+    ...wake,
+    attempts,
+    spawned,
+    woke_at,
+    woke_pid: pid,
+    idle_since: void 0
+  };
+}
+function mark_idle(wake, now) {
+  return wake.idle_since === void 0 ? { ...wake, idle_since: now.toISOString() } : wake;
+}
+function count_claim(wake) {
+  const woke = wake.woke_at === void 0 ? wake.woke : wake.woke + ONE_WAKE;
+  return {
+    ...wake,
+    woke,
+    launch_at: wake.woke_at ?? wake.launch_at,
+    woke_at: void 0,
+    attempts: void 0,
+    idle_since: void 0
+  };
+}
+function is_own_wake(wake) {
+  return process_identity.is_own_process(wake.pid, wake.process_start);
+}
+function read_own_wake(target) {
+  const wake = read_wake(target);
+  return wake !== void 0 && is_own_wake(wake) ? wake : void 0;
+}
+function tidy_own_wake(target) {
+  const wake = read_wake(target);
+  if (wake === void 0) return "absent";
+  if (!is_own_wake(wake)) return "superseded";
+  remove_wake(target);
+  return "removed";
+}
+function update_wake(target, wake) {
+  if (read_own_wake(target) === void 0) return false;
+  write_wake(target, wake);
+  return true;
+}
+var run_wake = {
+  IDLE_CEILING_MS,
+  MAX_WAKE_ATTEMPTS,
+  WAKE_GRACE_MS,
+  claim,
+  count_claim,
+  count_wake,
+  decide,
+  fresh_wake,
+  is_supervisor_live,
+  mark_idle,
+  parse_wake,
+  read_own_wake,
+  read_wake,
+  remove_wake,
+  tidy_own_wake,
+  update_wake,
+  wake_log_path,
+  wake_path,
+  write_wake
+};
+
+export {
+  run_wake
+};

package/dist/commands/chunk-QFIKPGMC.js

@@ -0,0 +1,280 @@
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  find_local_bin_upwards
+} from "./chunk-SVV4U5AR.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  LINT_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lines/line-budget.ts
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
+import path2 from "node:path";
+import { execa } from "execa";
+import { z as z2 } from "zod";
+
+// scripts/lines/effective-limit.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+var ESLINT_MODULE = "eslint";
+var MAX_LINES_RULE = "max-lines";
+var SEVERITY_OFF = 0;
+var SEVERITY_OFF_NAME = "off";
+var CONFIG_FILE_OPTION = "overrideConfigFile";
+var module_schema = z.object({
+  ESLint: z.custom((value) => typeof value === "function")
+});
+var options_schema = z.looseObject({ max: z.number().int().positive() });
+var max_schema = z.number().int().positive();
+var severity_schema = z.union([z.number(), z.string()]);
+var entry_schema = z.tuple([severity_schema, z.union([max_schema, options_schema])]);
+var config_schema = z.object({ rules: z.record(z.string(), z.unknown()).optional() });
+var INTEGER_SKIPS = { skipBlankLines: false, skipComments: false };
+function is_off(severity) {
+  return severity === SEVERITY_OFF || severity === SEVERITY_OFF_NAME;
+}
+function normalized(option) {
+  return typeof option === "number" ? { max: option, ...INTEGER_SKIPS } : option;
+}
+function options_in(config) {
+  const rules = config_schema.safeParse(config).data?.rules ?? {};
+  const entry = entry_schema.safeParse(rules[MAX_LINES_RULE]);
+  if (!entry.success) return void 0;
+  const [severity, option] = entry.data;
+  return is_off(severity) ? void 0 : normalized(option);
+}
+async function resolver_for(project_root, config_file) {
+  try {
+    const require_from = createRequire(path.join(project_root, PACKAGE_JSON));
+    const loaded = await import(pathToFileURL(require_from.resolve(ESLINT_MODULE)).href);
+    const eslint_module = module_schema.parse(loaded);
+    return new eslint_module.ESLint({
+      cwd: project_root,
+      ...config_file !== void 0 && { [CONFIG_FILE_OPTION]: config_file }
+    });
+  } catch {
+    return void 0;
+  }
+}
+async function entry_for(resolver, file_path) {
+  try {
+    const options = options_in(await resolver.calculateConfigForFile(file_path));
+    return options === void 0 ? void 0 : [path.resolve(file_path), options];
+  } catch {
+    return void 0;
+  }
+}
+async function options_for(file_paths, project_root, config_file) {
+  const found = /* @__PURE__ */ new Map();
+  const resolver = file_paths.length === 0 ? void 0 : await resolver_for(project_root, config_file);
+  if (resolver === void 0) return found;
+  const entries = await Promise.all(
+    file_paths.map(async (file_path) => await entry_for(resolver, file_path))
+  );
+  const resolved = entries.filter((entry) => entry !== void 0);
+  for (const [file_path, options] of resolved) found.set(file_path, options);
+  return found;
+}
+var effective_limit = {
+  options_for,
+  options_in
+};
+
+// scripts/lines/line-budget.ts
+var MAX_LINES_RULE2 = "max-lines";
+var PROBE_MAX = 0;
+var PROBE_SEVERITY = "error";
+var NO_HEADROOM = 0;
+var NO_CODE_LINES = 0;
+var COUNT_PATTERN = /\((\d+)\)/u;
+var COUNT_GROUP = 1;
+var NEAR_LIMIT_FRACTION = 0.85;
+var PERCENT = 100;
+var ESLINT_BIN = "eslint";
+var PNPM = "pnpm";
+var PNPM_EXEC = "exec";
+var FORMAT_FLAGS = ["--format", "json", "--no-inline-config"];
+var RULE_FLAG = "--rule";
+var CACHE_PREFIX = "josh-lines-eslint-cache-";
+var CACHE_LOCATION_FLAG = "--cache-location";
+var CACHE_KEY_LENGTH = 8;
+var message_schema = z2.object({ ruleId: z2.string().nullish(), message: z2.string() });
+var result_schema = z2.object({ filePath: z2.string(), messages: z2.array(message_schema) });
+var results_schema = z2.array(result_schema);
+function near_limit_threshold(limit) {
+  return Math.ceil(limit * NEAR_LIMIT_FRACTION);
+}
+function near_limit_percent() {
+  return Math.round(NEAR_LIMIT_FRACTION * PERCENT);
+}
+function budget_of(code_lines, limit) {
+  return {
+    code_lines,
+    limit,
+    headroom: limit - code_lines,
+    is_near_limit: code_lines >= near_limit_threshold(limit)
+  };
+}
+function probe_rules(options) {
+  return { [MAX_LINES_RULE2]: [PROBE_SEVERITY, { ...options, max: PROBE_MAX }] };
+}
+function probe_rule(options) {
+  return JSON.stringify(probe_rules(options));
+}
+function cache_prefix(key) {
+  const digest = createHash("sha256").update(key).digest("hex").slice(0, CACHE_KEY_LENGTH);
+  return `${CACHE_PREFIX}${digest}-`;
+}
+function probe_arguments(group, project_root) {
+  return [
+    ...FORMAT_FLAGS,
+    RULE_FLAG,
+    probe_rule(group.options),
+    CACHE_LOCATION_FLAG,
+    stamp_file.stamp_path(cache_prefix(group.key), project_root),
+    ...group.paths
+  ];
+}
+function probe_command(project_root, probe_args) {
+  const shim = find_local_bin_upwards(project_root, ESLINT_BIN);
+  return shim === void 0 ? [PNPM, PNPM_EXEC, ESLINT_BIN, ...probe_args] : [shim, ...probe_args];
+}
+async function run_probe(group, project_root) {
+  const [bin, ...command_arguments] = probe_command(
+    project_root,
+    probe_arguments(group, project_root)
+  );
+  try {
+    const result = await execa(bin ?? PNPM, command_arguments, {
+      cwd: project_root,
+      reject: false,
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: LINT_TIMEOUT_MS
+    });
+    return result.stdout;
+  } catch {
+    return void 0;
+  }
+}
+function count_in_message(message) {
+  const raw = COUNT_PATTERN.exec(message)?.[COUNT_GROUP];
+  return raw === void 0 ? void 0 : Number(raw);
+}
+function count_in(messages) {
+  const reported = messages.find((message) => message.ruleId === MAX_LINES_RULE2);
+  return reported === void 0 ? void 0 : count_in_message(reported.message);
+}
+function count_or_zero(messages) {
+  const counted = count_in(messages);
+  if (counted !== void 0) return counted;
+  const is_refused = messages.some((message) => message.ruleId === null);
+  return is_refused ? void 0 : NO_CODE_LINES;
+}
+function counts_from(results) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const code_lines = count_or_zero(result.messages);
+    if (code_lines !== void 0) counts.set(path2.resolve(result.filePath), code_lines);
+  }
+  return counts;
+}
+function parse_counts(raw_output = "null") {
+  const results = json_value.parse_with(raw_output, results_schema);
+  return results === void 0 ? /* @__PURE__ */ new Map() : counts_from(results);
+}
+function is_lintable_path(file_path) {
+  try {
+    return statSync(file_path, { throwIfNoEntry: false })?.isFile() === true;
+  } catch {
+    return false;
+  }
+}
+function lintable_paths(file_paths) {
+  return file_paths.filter((file_path) => is_lintable_path(file_path));
+}
+function options_key(options) {
+  return JSON.stringify(
+    options,
+    Object.keys(options).toSorted((left, right) => left.localeCompare(right))
+  );
+}
+function grouped(options_by_path) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [file_path, options] of options_by_path) {
+    const key = options_key(options);
+    const group = groups.get(key) ?? { key, options, paths: [] };
+    group.paths.push(file_path);
+    groups.set(key, group);
+  }
+  return groups;
+}
+async function counts_for(options_by_path, project_root) {
+  const groups = [];
+  for (const [, group] of grouped(options_by_path)) groups.push(group);
+  const outputs = await Promise.all(
+    groups.map(async (group) => await run_probe(group, project_root))
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const output of outputs) {
+    for (const [file_path, code_lines] of parse_counts(output)) counts.set(file_path, code_lines);
+  }
+  return counts;
+}
+function budget_for(code_lines, limit) {
+  if (code_lines === void 0 || limit === void 0) return void 0;
+  return budget_of(code_lines, limit);
+}
+async function budgets_for(file_paths, project_root) {
+  const options = await effective_limit.options_for(lintable_paths(file_paths), project_root);
+  const counts = await counts_for(options, project_root);
+  return file_paths.map((file_path) => {
+    const resolved = path2.resolve(file_path);
+    const code_lines = counts.get(resolved);
+    const limit = options.get(resolved)?.max;
+    return { file_path, limit, budget: budget_for(code_lines, limit) };
+  });
+}
+function describe(budget) {
+  const share = Math.floor(budget.code_lines / budget.limit * PERCENT);
+  const remaining = budget.headroom < NO_HEADROOM ? `${String(-budget.headroom)} over` : `${String(budget.headroom)} to spare`;
+  const counted = `${String(budget.code_lines)}/${String(budget.limit)}`;
+  return `${counted} code lines (${String(share)}%), ${remaining}`;
+}
+function advice(budget) {
+  if (budget.headroom < NO_HEADROOM) return "over the limit: split it before the gate reports it";
+  if (!budget.is_near_limit) return void 0;
+  return "near the limit: declare the splitting plan in Step 0 before writing into it";
+}
+var line_budget = {
+  advice,
+  budget_of,
+  budgets_for,
+  counts_from,
+  describe,
+  grouped,
+  is_lintable_path,
+  near_limit_percent,
+  near_limit_threshold,
+  parse_counts,
+  probe_arguments,
+  probe_command,
+  probe_rule,
+  probe_rules,
+  NEAR_LIMIT_FRACTION
+};
+
+export {
+  effective_limit,
+  line_budget
+};

package/dist/commands/chunk-QSBYULSS.js

@@ -0,0 +1,100 @@
+import {
+  has_stderr_field
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/git/git-error.ts
+function get_stderr_from_error(cause) {
+  if (!has_stderr_field(cause)) return void 0;
+  const stderr = cause.stderr.trim();
+  return stderr.length > 0 ? stderr : void 0;
+}
+function get_error_message_from_cause(cause) {
+  const message = cause.message.trim();
+  if (message.length > 0) return message;
+  return get_stderr_from_error(cause);
+}
+function get_cause_message(cause) {
+  if (cause instanceof Error) return get_error_message_from_cause(cause);
+  if (typeof cause === "string") return cause.trim();
+  return void 0;
+}
+var FAILURE_PREFIX = "\u274C Error:";
+var DETAILS_PREFIX = "\u{1F4A1} Details:";
+function display_error_details(cause) {
+  const cause_message = get_cause_message(cause);
+  if (cause_message === void 0 || cause_message.length === 0) return;
+  console.error("");
+  console.error(DETAILS_PREFIX, cause_message);
+}
+var FAILURE_EXIT_CODE = 1;
+var OPERATION_CANCELLED_MESSAGE = "\u{1F4A1} Operation cancelled.";
+var BranchMismatchError = class extends Error {
+  current_branch;
+  target_branch_name;
+  constructor(mismatch, options) {
+    super(
+      `Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
+      options
+    );
+    this.name = "BranchMismatchError";
+    this.current_branch = mismatch.current_branch;
+    this.target_branch_name = mismatch.target_branch_name;
+  }
+};
+var OperationCancelledError = class extends Error {
+  constructor() {
+    super("Operation cancelled");
+    this.name = "OperationCancelledError";
+  }
+};
+function display_failure(error) {
+  const error_message = error_text.message_of(error);
+  console.error("");
+  console.error(FAILURE_PREFIX, error_message);
+  if (error instanceof Error && error.cause !== void 0) {
+    display_error_details(error.cause);
+  }
+  console.error("");
+}
+function display_branch_mismatch(error) {
+  console.error("");
+  console.error("\u274C Branch mismatch detected");
+  console.error("");
+  console.error(`Current branch: ${error.current_branch}`);
+  console.error(`Expected branch: ${error.target_branch_name}`);
+  console.error("");
+  console.error("\u{1F4A1} Please update main branch to the latest and try again.");
+}
+function display_cancelled() {
+  console.info(OPERATION_CANCELLED_MESSAGE);
+  console.info("");
+}
+function display(error) {
+  if (error instanceof BranchMismatchError) {
+    display_branch_mismatch(error);
+    return;
+  }
+  if (error instanceof OperationCancelledError) {
+    display_cancelled();
+    return;
+  }
+  display_failure(error);
+}
+function handle(error) {
+  display(error);
+  process.exitCode = FAILURE_EXIT_CODE;
+}
+var git_error = {
+  DETAILS_PREFIX,
+  FAILURE_PREFIX,
+  handle
+};
+
+export {
+  BranchMismatchError,
+  OperationCancelledError,
+  git_error
+};

package/dist/commands/chunk-QSJCZATC.js

@@ -0,0 +1,18 @@
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/release/release-approval-prune.ts
+var APPROVAL_DIRECTORY = ".josh/metrics-accepted";
+var APPROVAL_PREFIX = `${APPROVAL_DIRECTORY}/`;
+async function prune() {
+  await git_spawn.read(["rm", "-r", "-q", "--ignore-unmatch", "--", APPROVAL_DIRECTORY]);
+}
+function is_approval(file) {
+  return file.startsWith(APPROVAL_PREFIX);
+}
+var release_approval_prune = { APPROVAL_DIRECTORY, is_approval, prune };
+
+export {
+  release_approval_prune
+};

package/dist/commands/chunk-QTJPCXEW.js

@@ -0,0 +1,23 @@
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+
+// scripts/issue/issue-fold.ts
+var FOLD = "fold";
+var SEPARATE = "separate";
+var NO_FOLD_NEEDED = "no-fold-needed";
+var UNDETERMINED = "undetermined";
+var MIN_CANDIDATES = 2;
+function separable_verdict(size_verdict) {
+  if (size_verdict === void 0) return UNDETERMINED;
+  return size_verdict === split_assess.SPLIT_VERDICT ? SEPARATE : FOLD;
+}
+function fold_verdict(candidate_count, is_separable, size_verdict) {
+  if (candidate_count < MIN_CANDIDATES) return NO_FOLD_NEEDED;
+  return is_separable ? separable_verdict(size_verdict) : FOLD;
+}
+var issue_fold = { FOLD, SEPARATE, NO_FOLD_NEEDED, UNDETERMINED, MIN_CANDIDATES, fold_verdict };
+
+export {
+  issue_fold
+};