@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-HYQ5Q6AE.js

@@ -0,0 +1,304 @@
+import {
+  process_directories
+} from "./chunk-NZ45KOLL.js";
+import {
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  figure_format
+} from "./chunk-OYZP5ANC.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider,
+  time_instant
+} from "./chunk-DDZVMXZD.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/board/run-board-quota-read.ts
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/agent/codex-home-source.ts
+import os from "node:os";
+import path from "node:path";
+function default_home() {
+  return path.join(os.homedir(), ".codex");
+}
+var codex_home_source = { default_home };
+
+// scripts/run/board/run-board-quota-read.ts
+import { z as z2 } from "zod";
+
+// scripts/run/board/run-board-quota-lane.ts
+import { z } from "zod";
+var CODEX_META = z.looseObject({
+  type: z.literal("session_meta"),
+  payload: z.looseObject({ cwd: z.string() })
+});
+function codex_lane(head, root = process.env[lane_paths.LANE_ROOT_KEY] ?? "") {
+  const meta = head.split("\n").map((line) => json_value.parse_with(line, CODEX_META));
+  const cwd = meta.find((event) => event !== void 0)?.payload.cwd;
+  return cwd === void 0 ? void 0 : process_directories.lane_of(cwd, root);
+}
+var run_board_quota_lane = { codex_lane };
+
+// scripts/run/board/run-board-quota-read.ts
+var MS_PER_SECOND = 1e3;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var MINUTES_PER_DAY = MINUTES_PER_HOUR * HOURS_PER_DAY;
+var SHORT_WINDOW_HOURS = 5;
+var FIVE_HOURS_MINUTES = SHORT_WINDOW_HOURS * MINUTES_PER_HOUR;
+var DAYS_PER_WEEK = 7;
+var SEVEN_DAYS_MINUTES = DAYS_PER_WEEK * MINUTES_PER_DAY;
+var PERCENT = 100;
+var TAIL_BYTES = 262144;
+var TAIL_GROWTH = 8;
+var TAIL_LIMIT_BYTES = TAIL_BYTES * TAIL_GROWTH * TAIL_GROWTH;
+var SAMPLE_SIZE = 10;
+var SCAN_FACTOR = 3;
+var FILES_SCANNED = SAMPLE_SIZE * SCAN_FACTOR;
+var FILES_LIMIT = FILES_SCANNED * SCAN_FACTOR * SCAN_FACTOR;
+var MS_PER_DAY = MINUTES_PER_DAY * MINUTES_PER_HOUR * MS_PER_SECOND;
+var CLAUDE_MARK = '"rate_limit_event"';
+var CODEX_MARK = '"rate_limits":{';
+var CODEX_PREFIX = "rollout-";
+var CODEX_SUFFIX = ".jsonl";
+var LOG_SUFFIX = ".log";
+var TIMESTAMP_MARK = '"timestamp"';
+var LAUNCH_HEADER = /^=== (?<stamp>\S+) · started by process /u;
+var LAUNCH_HEADERS = /^=== \S+ · started by process .*$/gmu;
+var HEADER_PROVIDER = / · provider=(?<provider>\S+)/u;
+var { two_digits } = figure_format;
+var CLAUDE_WINDOW = z2.looseObject({ utilization: z2.number(), resetsAt: z2.number() });
+var CLAUDE_WINDOWS = z2.looseObject({
+  five_hour: CLAUDE_WINDOW.optional(),
+  seven_day: CLAUDE_WINDOW.optional()
+});
+var CLAUDE_INFO = z2.looseObject({ unifiedWindows: CLAUDE_WINDOWS });
+var CLAUDE_EVENT = z2.looseObject({
+  type: z2.literal("rate_limit_event"),
+  rate_limit_info: CLAUDE_INFO,
+  timestamp: z2.string().nullish().catch(void 0)
+});
+var CODEX_WINDOW = z2.looseObject({
+  used_percent: z2.number(),
+  window_minutes: z2.number(),
+  resets_at: z2.number()
+});
+var CODEX_LIMITS = z2.looseObject({
+  primary: CODEX_WINDOW.nullish(),
+  secondary: CODEX_WINDOW.nullish()
+});
+var CODEX_EVENT = z2.looseObject({
+  payload: z2.looseObject({ rate_limits: CODEX_LIMITS }),
+  timestamp: z2.string().nullish().catch(void 0)
+});
+var TIMED_LINE = z2.looseObject({ timestamp: z2.string() });
+function claude_window(minutes, window) {
+  if (window === void 0) return [];
+  const resets_ms = window.resetsAt * MS_PER_SECOND;
+  return [{ minutes, used_percent: Math.round(window.utilization * PERCENT), resets_ms }];
+}
+function claude_line(line) {
+  if (!line.includes(CLAUDE_MARK)) return void 0;
+  const event = json_value.parse_with(line, CLAUDE_EVENT);
+  if (event === void 0) return void 0;
+  const { five_hour, seven_day } = event.rate_limit_info.unifiedWindows;
+  return {
+    windows: [
+      ...claude_window(FIVE_HOURS_MINUTES, five_hour),
+      ...claude_window(SEVEN_DAYS_MINUTES, seven_day)
+    ],
+    taken_ms: time_instant.parse_instant(event.timestamp)
+  };
+}
+function codex_window(window) {
+  if (window === void 0 || window === null) return [];
+  const { used_percent, window_minutes, resets_at } = window;
+  return [{ minutes: window_minutes, used_percent, resets_ms: resets_at * MS_PER_SECOND }];
+}
+function codex_line(line) {
+  if (!line.includes(CODEX_MARK)) return void 0;
+  const event = json_value.parse_with(line, CODEX_EVENT);
+  if (event === void 0) return void 0;
+  const { primary, secondary } = event.payload.rate_limits;
+  return {
+    windows: [...codex_window(primary), ...codex_window(secondary)],
+    taken_ms: time_instant.parse_instant(event.timestamp)
+  };
+}
+function codex_heads(text) {
+  return text.split("\n").map((line) => codex_line(line)).filter((reading) => reading !== void 0);
+}
+function json_stamp(line) {
+  if (!line.includes(TIMESTAMP_MARK)) return void 0;
+  return json_value.parse_with(line, TIMED_LINE)?.timestamp;
+}
+function line_stamp(line) {
+  const stamp = LAUNCH_HEADER.exec(line)?.groups?.["stamp"];
+  return stamp ?? json_stamp(line);
+}
+function line_ms(line) {
+  return time_instant.parse_instant(line_stamp(line));
+}
+function time_before(lines, index) {
+  const timed = lines.slice(0, index).findLast((line) => line_ms(line) !== void 0);
+  return timed === void 0 ? void 0 : line_ms(timed);
+}
+function claude_at(lines, index) {
+  const reading = claude_line(lines[index] ?? "");
+  if (reading === void 0 || reading.taken_ms !== void 0) return reading;
+  return { ...reading, taken_ms: time_before(lines, index) };
+}
+function claude_reading(text) {
+  const lines = text.split("\n");
+  return claude_at(
+    lines,
+    lines.findLastIndex((line) => claude_line(line) !== void 0)
+  );
+}
+function codex_reading(text) {
+  return codex_heads(text).at(-1);
+}
+function claude_heads(text) {
+  const lines = text.split("\n");
+  return lines.flatMap((_line, index) => claude_at(lines, index) ?? []);
+}
+async function names_in(directory) {
+  try {
+    return await readdir(directory);
+  } catch {
+    return [];
+  }
+}
+async function file_of(file) {
+  try {
+    const { mtimeMs: mtime_ms } = await stat(file);
+    return [{ path: file, mtime_ms }];
+  } catch {
+    return [];
+  }
+}
+async function files_in(directory, is_wanted) {
+  const names = await names_in(directory);
+  const wanted = names.filter((name) => is_wanted(name));
+  const files = await Promise.all(
+    wanted.map(async (name) => await file_of(path2.join(directory, name)))
+  );
+  return files.flat();
+}
+function sorted(files) {
+  return files.toSorted((left, right) => right.mtime_ms - left.mtime_ms);
+}
+function newest(files, limit) {
+  return sorted(files).slice(0, limit);
+}
+function is_lane_log(name) {
+  const prefixes = [durable_state.PREFIX.LANE_DISPATCH, durable_state.PREFIX.HANDOFF_LOG];
+  return prefixes.some((prefix) => name.startsWith(prefix)) && name.endsWith(LOG_SUFFIX);
+}
+function last_provider(text) {
+  const header = text.match(LAUNCH_HEADERS)?.at(-1) ?? "";
+  return HEADER_PROVIDER.exec(header)?.groups?.["provider"];
+}
+function is_claude_launch(text) {
+  const provider = last_provider(text);
+  return provider === void 0 || provider === agent_provider.ANTHROPIC_PROVIDER;
+}
+var CLAUDE_LAUNCHES = /* @__PURE__ */ new Map();
+async function read_claude_launch(file) {
+  const known = CLAUDE_LAUNCHES.get(file.path);
+  if (known?.mtime_ms === file.mtime_ms) return known.is_claude;
+  const is_claude = is_claude_launch(await readFile(file.path, "utf8"));
+  CLAUDE_LAUNCHES.set(file.path, { mtime_ms: file.mtime_ms, is_claude });
+  return is_claude;
+}
+async function claude_log(file) {
+  try {
+    return await read_claude_launch(file) ? [file] : [];
+  } catch {
+    return [];
+  }
+}
+async function claude_files(root = durable_state.root(), limit = FILES_SCANNED) {
+  const scanned = newest(await files_in(root, is_lane_log), FILES_LIMIT);
+  const claude = [];
+  for (const file of scanned) {
+    if (claude.length >= limit) break;
+    claude.push(...await claude_log(file));
+  }
+  return claude;
+}
+function is_rollout(name) {
+  return name.startsWith(CODEX_PREFIX) && name.endsWith(CODEX_SUFFIX);
+}
+function day_directory(sessions, ms) {
+  const date = new Date(ms);
+  const month = two_digits(date.getMonth() + 1);
+  return path2.join(sessions, String(date.getFullYear()), month, two_digits(date.getDate()));
+}
+function codex_home() {
+  return process.env["CODEX_HOME"] ?? codex_home_source.default_home();
+}
+async function codex_files(now_ms, home = codex_home(), limit = FILES_SCANNED) {
+  const sessions = path2.join(home, "sessions");
+  const back = Array.from({ length: DAYS_PER_WEEK }, (_, day) => now_ms - day * MS_PER_DAY);
+  const days = back.map((ms) => day_directory(sessions, ms));
+  const found = await Promise.all(days.map(async (day) => await files_in(day, is_rollout)));
+  return newest(found.flat(), limit);
+}
+async function read_tail(file, bytes = TAIL_BYTES) {
+  return transcript_tail.read_tail(file, bytes);
+}
+async function read_head(file, bytes = TAIL_BYTES) {
+  const handle = await open(file, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead: read } = await handle.read(buffer, 0, bytes, 0);
+    return buffer.subarray(0, read).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function is_last_tail(reading, text, bytes) {
+  return (reading?.windows.length ?? 0) > 0 || Buffer.byteLength(text) < bytes || bytes >= TAIL_LIMIT_BYTES;
+}
+async function reading_in(tail_of, reading_of, bytes = TAIL_BYTES) {
+  const text = await tail_of(bytes);
+  const reading = reading_of(text);
+  if (is_last_tail(reading, text, bytes)) return reading;
+  return await reading_in(tail_of, reading_of, bytes * TAIL_GROWTH);
+}
+var run_board_quota_read = {
+  FILES_LIMIT,
+  FILES_SCANNED,
+  FIVE_HOURS_MINUTES,
+  SAMPLE_SIZE,
+  SCAN_FACTOR,
+  SEVEN_DAYS_MINUTES,
+  TAIL_BYTES,
+  TAIL_LIMIT_BYTES,
+  claude_files,
+  claude_heads,
+  claude_reading,
+  codex_files,
+  codex_heads,
+  codex_lane: run_board_quota_lane.codex_lane,
+  codex_reading,
+  read_head,
+  line_stamp,
+  read_tail,
+  reading_in
+};
+
+export {
+  run_board_quota_read
+};

package/dist/commands/chunk-HYVAEK6M.js

@@ -0,0 +1,155 @@
+import {
+  issue_priority
+} from "./chunk-FBWNL3UA.js";
+import {
+  issue_run_hold
+} from "./chunk-QX2R6UJG.js";
+import {
+  ALREADY_DONE_LABEL,
+  AUTO_OK_LABEL,
+  EPIC_LABEL,
+  IN_PROGRESS_LABEL,
+  NEEDS_DECISION_LABEL,
+  NEEDS_HUMAN_MERGE_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
+  PRIORITY_HIGH_LABEL,
+  RUN_LANE_LABEL,
+  RUN_STALLED_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+
+// scripts/run/add/run-add-epic.ts
+function is_epic(labels) {
+  return has_label_name(labels, EPIC_LABEL);
+}
+function tracked_of(carry) {
+  return new Set(run_carry.remaining_of(carry));
+}
+function track(issue, tracked = /* @__PURE__ */ new Set()) {
+  return { kind: "tracked", issue, is_new: !tracked.has(issue) };
+}
+function describe(issue, is_new, is_priority) {
+  if (!is_new) return `tracking ${issue} \xB7 already a root of this run`;
+  return `tracking ${issue} \xB7 epic root, ${is_priority ? "ahead of the queue" : "end of the queue"}`;
+}
+function event_text(issue) {
+  return `added ${issue} \xB7 tracked as an epic root`;
+}
+var run_add_epic = { describe, event_text, is_epic, track, tracked_of };
+
+// scripts/run/add/run-add.ts
+var DEFAULT_CONTEXT = { is_retry: false, done: [], active: /* @__PURE__ */ new Set() };
+var PROTECTED_LABELS = [NEEDS_DECISION_LABEL, NEEDS_HUMAN_REVIEW_LABEL, ALREADY_DONE_LABEL];
+var ISSUE_PREFIX = "#";
+var BLOCKER_SEPARATOR = ", ";
+function labels_for(is_priority, existing = []) {
+  const opted_in = [AUTO_OK_LABEL, RUN_LANE_LABEL];
+  return is_priority && !issue_priority.is_typed(existing) ? [...opted_in, PRIORITY_HIGH_LABEL] : opted_in;
+}
+async function first_failed(issue, labels, write) {
+  const [label, ...rest] = labels;
+  if (label === void 0) return void 0;
+  if (!await write(issue, label)) return label;
+  return await first_failed(issue, rest, write);
+}
+function stops_of(issue, context) {
+  if (!context.is_retry) return [];
+  return context.repairs?.has(issue) === true ? [RUN_STALLED_LABEL, NEEDS_HUMAN_MERGE_LABEL, IN_PROGRESS_LABEL] : [RUN_STALLED_LABEL];
+}
+function retry_required(issue, labels, context) {
+  return !context.is_retry && (context.done.includes(issue) || has_label_name(labels, RUN_STALLED_LABEL));
+}
+function terminal_refusal(issue, context) {
+  return context.settled?.has(issue) ? "not a mechanical stop" : void 0;
+}
+function protected_label(labels) {
+  return PROTECTED_LABELS.find((label) => has_label_name(labels, label));
+}
+function label_refusal(labels) {
+  return protected_label(labels) ?? (issue_run_hold.is_held(labels) ? IN_PROGRESS_LABEL : void 0);
+}
+function refusal(issue, view, context) {
+  const labels = view.labels ?? [];
+  const label = label_refusal(labels);
+  if (label !== void 0) return label;
+  if (context.active.has(String(issue))) return "active lane";
+  if (retry_required(issue, labels, context)) return "use --retry";
+  return terminal_refusal(issue, context);
+}
+async function label_one(issue, labels, ports, context) {
+  const label = await first_failed(issue, labels, ports.apply_label);
+  if (label !== void 0) return { kind: "unlabeled", issue, label };
+  const stop = await first_failed(issue, stops_of(issue, context), ports.clear_label);
+  if (stop !== void 0) return { kind: "refused", issue, reason: `could not clear ${stop}` };
+  return { kind: "queued", issue, blockers: [] };
+}
+function decided(issue, view, context) {
+  const reason = refusal(issue, view, context);
+  if (reason !== void 0) return { kind: "refused", issue, reason };
+  return run_add_epic.is_epic(view.labels ?? []) ? run_add_epic.track(issue, context.tracked) : void 0;
+}
+async function add_one(issue, is_priority, ports, context) {
+  const view = await ports.read_issue(issue);
+  if (view === void 0) return { kind: "unreadable", issue };
+  if (!view.is_open) return { kind: "closed", issue };
+  const settled = decided(issue, view, context);
+  if (settled !== void 0) return settled;
+  const outcome = await label_one(issue, labels_for(is_priority, view.labels), ports, context);
+  return outcome.kind === "queued" ? { ...outcome, blockers: view.blockers } : outcome;
+}
+async function add_all(issues, is_priority, ports, context = DEFAULT_CONTEXT) {
+  const [issue, ...rest] = issues;
+  if (issue === void 0) return [];
+  const outcome = await add_one(issue, is_priority, ports, context);
+  return [outcome, ...await add_all(rest, is_priority, ports, context)];
+}
+function is_added(outcome) {
+  return outcome.kind === "queued" || outcome.kind === "tracked" && outcome.is_new;
+}
+function additions_of(outcomes, is_priority) {
+  return outcomes.filter((outcome) => is_added(outcome)).map((outcome) => ({ issue: outcome.issue, is_priority }));
+}
+function roots_of(outcomes) {
+  return new Set(
+    outcomes.filter((outcome) => outcome.kind === "tracked" && outcome.is_new).map((outcome) => outcome.issue)
+  );
+}
+function blockers_text(blockers) {
+  return blockers.map((blocker) => `${ISSUE_PREFIX}${String(blocker)}`).join(BLOCKER_SEPARATOR);
+}
+function queued_line(issue, blockers, is_priority) {
+  if (blockers.length > 0) return `queued ${issue} \xB7 waiting: blocked by ${blockers_text(blockers)}`;
+  return `queued ${issue} \xB7 ${is_priority ? "next free lane" : "end of the queue"}`;
+}
+function refused_reason(outcome) {
+  if (outcome.kind === "closed") return "closed";
+  if (outcome.kind === "unreadable") return "could not be read";
+  if (outcome.kind === "refused") return outcome.reason;
+  return `could not apply \`${outcome.label}\``;
+}
+function describe2(outcome, is_priority) {
+  const issue = `${ISSUE_PREFIX}${String(outcome.issue)}`;
+  if (outcome.kind === "queued") return queued_line(issue, outcome.blockers, is_priority);
+  if (outcome.kind === "tracked") return run_add_epic.describe(issue, outcome.is_new, is_priority);
+  return `refused ${issue} \xB7 ${refused_reason(outcome)}`;
+}
+function is_all_added(outcomes) {
+  return outcomes.every((outcome) => outcome.kind === "queued" || outcome.kind === "tracked");
+}
+var run_add = {
+  add_all,
+  additions_of,
+  describe: describe2,
+  is_all_added,
+  labels_for,
+  protected_label,
+  roots_of
+};
+
+export {
+  run_add_epic,
+  run_add
+};

package/dist/commands/chunk-I2HHXZVG.js

@@ -0,0 +1,46 @@
+import {
+  run_handoff_launch
+} from "./chunk-CRCQOA4Z.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+
+// scripts/backlog/backlog-drive-unit.ts
+function log_path(git_directory, label, now) {
+  return durable_state.path(
+    durable_state.PREFIX.HANDOFF_LOG,
+    git_directory,
+    `-${label}-${String(now)}.log`
+  );
+}
+function request_of(prompt, launch, log) {
+  const selected = agent_provider.resolve_provider(launch.environment);
+  if (selected.kind === "rejected") return void 0;
+  const child = {
+    prompt,
+    role: agent_role_profile.SCHEDULER,
+    provider: selected.provider,
+    cwd: launch.cwd
+  };
+  const built = run_handoff_launch.argv_of(child, launch.environment);
+  if (built.kind === "rejected") return void 0;
+  return run_handoff_launch.request_of(built, launch.cwd, log);
+}
+async function launch_attached(request) {
+  return await detached_launch.launch_attached(request, (note) => process.stderr.write(`${note}
+`));
+}
+var backlog_drive_unit = { log_path, request_of, launch_attached };
+
+export {
+  backlog_drive_unit
+};