@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-AV26CMY6.js

@@ -0,0 +1,304 @@
+import {
+  process_directories
+} from "./chunk-NZ45KOLL.js";
+import {
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  figure_format
+} from "./chunk-7EAYFMDN.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.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-B2PJEV3S.js

@@ -0,0 +1,246 @@
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-read-map.ts
+import { readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-read-trace.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var RECORD_DIRECTORY_KEY = "JOSH_TEST_READS_DIRECTORY";
+var ROOT_KEY = "JOSH_TEST_READS_ROOT";
+var FILE_URL_PREFIX = "file://";
+var NODE_MODULES = "node_modules";
+var GIT_DIRECTORY = ".git";
+var ROOT_ENTRY = ".";
+var LISTING_READS = /* @__PURE__ */ new Set([
+  "readdir",
+  "readdirSync",
+  "opendir",
+  "opendirSync"
+]);
+var KIND_SUFFIX = { listing: "*", walk: "**" };
+function is_recursive(options) {
+  return typeof options === "object" && options !== null && Reflect.get(options, "recursive") === true;
+}
+function read_kind(name, options) {
+  if (!LISTING_READS.has(name)) return "path";
+  return is_recursive(options) ? "walk" : "listing";
+}
+function read_key(relative, kind) {
+  return kind === "path" ? relative : path.join(relative, KIND_SUFFIX[kind]);
+}
+function script_path(script_name) {
+  if (script_name.startsWith(FILE_URL_PREFIX)) return fileURLToPath(script_name);
+  return path.isAbsolute(script_name) ? script_name : void 0;
+}
+function is_outside(relative) {
+  return relative.startsWith("..") || path.isAbsolute(relative);
+}
+function is_ignored(relative) {
+  const segments = relative.split(path.sep);
+  return segments.includes(NODE_MODULES) || segments[0] === GIT_DIRECTORY;
+}
+function repository_path(root, file_path) {
+  const relative = path.relative(root, file_path);
+  if (relative === "") return ROOT_ENTRY;
+  return is_outside(relative) || is_ignored(relative) ? void 0 : relative;
+}
+function read_target(argument, cwd) {
+  if (typeof argument === "string") return path.resolve(cwd, argument);
+  if (argument instanceof URL) return fileURLToPath(argument);
+  return void 0;
+}
+function frame_reader(query, frame) {
+  const file_path = script_path(frame.script_name);
+  if (file_path === void 0 || file_path === query.recorder) return void 0;
+  const relative = repository_path(query.root, file_path);
+  return relative === ROOT_ENTRY ? void 0 : relative;
+}
+function stack_reader(query) {
+  const outermost = query.frames.findLast((frame) => frame_reader(query, frame) !== void 0);
+  if (outermost?.function_name !== "") return void 0;
+  return frame_reader(query, outermost);
+}
+function add_reader(records, read_path, reader) {
+  const readers = records.get(read_path) ?? /* @__PURE__ */ new Set();
+  readers.add(reader);
+  records.set(read_path, readers);
+}
+function to_records(records) {
+  return Object.fromEntries([...records].map(([read_path, readers]) => [read_path, [...readers]]));
+}
+var test_read_trace = {
+  RECORD_DIRECTORY_KEY,
+  ROOT_ENTRY,
+  ROOT_KEY,
+  add_reader,
+  read_key,
+  read_kind,
+  read_target,
+  repository_path,
+  script_path,
+  stack_reader,
+  to_records
+};
+
+// scripts/test/test-read-map.ts
+var MAP_VERSION = 8;
+var MAP_FILE_STEM = "test-read-map";
+var RECORD_EXTENSION = ".json";
+var STALE_AFTER_MS = 6048e5;
+function record_pairs(record) {
+  return Object.entries(record).flatMap(
+    ([read_path, readers]) => readers.map((reader) => [read_path, reader])
+  );
+}
+function merge_records(records) {
+  const merged = /* @__PURE__ */ new Map();
+  const pairs = records.flatMap((record) => record_pairs(record));
+  for (const [read_path, reader] of pairs) {
+    test_read_trace.add_reader(merged, read_path, reader);
+  }
+  return test_read_trace.to_records(merged);
+}
+function is_object(value) {
+  return typeof value === "object" && value !== null;
+}
+function is_string_array(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function is_read_records(value) {
+  return is_object(value) && Object.values(value).every(is_string_array);
+}
+function is_digest_record(value) {
+  if (!is_object(value) || Array.isArray(value)) return false;
+  return Object.values(value).every((digest) => typeof digest === "string");
+}
+var FIELD_CHECKS = [
+  ["version", (field) => field === MAP_VERSION],
+  ["commit", (field) => typeof field === "string"],
+  ["dirty", is_digest_record],
+  ["change", is_string_array],
+  ["directories", is_string_array],
+  ["readers", is_read_records]
+];
+function is_read_map(value) {
+  if (!is_object(value)) return false;
+  return FIELD_CHECKS.every(([field, is_valid]) => is_valid(Reflect.get(value, field)));
+}
+function changed_since_tree(map, since, current) {
+  const fresh = since.filter((file) => !Object.hasOwn(map.dirty, file));
+  const moved = Object.entries(map.dirty).filter(([file, digest]) => current[file] !== digest).map(([file]) => file);
+  return [.../* @__PURE__ */ new Set([...fresh, ...moved])];
+}
+function parse_map(text) {
+  const value = json_value.parse_or_undefined(text);
+  return is_read_map(value) ? value : void 0;
+}
+function parse_records(text) {
+  const value = json_value.parse_or_undefined(text);
+  return is_read_records(value) ? value : {};
+}
+function directories_above(relative) {
+  const parent = path2.dirname(relative);
+  if (parent === relative) return [];
+  return [parent, ...directories_above(parent)];
+}
+function created_directories(directories, recorded) {
+  return directories.filter(
+    (directory) => directory !== test_read_trace.ROOT_ENTRY && !recorded.has(directory)
+  );
+}
+function lookup_keys(relative, recorded) {
+  if (run_record_path.is_run_record(relative)) return [relative];
+  const directories = directories_above(relative);
+  const created = created_directories(directories, recorded);
+  const listed = [
+    directories[0] ?? test_read_trace.ROOT_ENTRY,
+    ...created.map((directory) => path2.dirname(directory))
+  ];
+  return [
+    relative,
+    ...created,
+    ...listed.map((directory) => test_read_trace.read_key(directory, "listing")),
+    ...directories.map((directory) => test_read_trace.read_key(directory, "walk"))
+  ];
+}
+function readers_of(map, relative) {
+  const keys = lookup_keys(relative, new Set(map.directories));
+  return [...new Set(keys.flatMap((key) => map.readers[key] ?? []))];
+}
+function in_unread_directory(map, relative) {
+  if (run_record_path.is_run_record(relative)) return true;
+  const directory = path2.dirname(relative);
+  const change = new Set(map.change);
+  const keys = Object.keys(map.readers).filter((key) => !change.has(key));
+  return keys.every((key) => path2.dirname(key) !== directory);
+}
+function map_path(root, version = MAP_VERSION) {
+  const common = git_common_directory.repository(root);
+  const name = `${MAP_FILE_STEM}.v${String(version)}${RECORD_EXTENSION}`;
+  return common === void 0 ? void 0 : path2.join(common, git_common_directory.STATE_DIRECTORY, name);
+}
+function is_map_file(name) {
+  return name.startsWith(MAP_FILE_STEM) && name.endsWith(RECORD_EXTENSION);
+}
+function is_stale(file_path, now) {
+  const modified = statSync(file_path, { throwIfNoEntry: false })?.mtimeMs ?? now;
+  return now - modified > STALE_AFTER_MS;
+}
+function prune_stale_maps(directory) {
+  const now = Date.now();
+  const maps = readdirSync(directory).filter((name) => is_map_file(name)).map((name) => path2.join(directory, name));
+  for (const file_path of maps) {
+    if (is_stale(file_path, now)) rmSync(file_path, { force: true });
+  }
+}
+function read_text(file_path) {
+  try {
+    return readFileSync(file_path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function read_map(root) {
+  const file_path = map_path(root);
+  const text = file_path === void 0 ? void 0 : read_text(file_path);
+  return text === void 0 ? void 0 : parse_map(text);
+}
+function write_map(root, map) {
+  const file_path = map_path(root, map.version);
+  if (file_path === void 0) return;
+  atomic_write.replace_file(file_path, JSON.stringify(map));
+  prune_stale_maps(path2.dirname(file_path));
+}
+function collect_records(directory) {
+  return readdirSync(directory).filter((name) => name.endsWith(RECORD_EXTENSION)).map((name) => parse_records(read_text(path2.join(directory, name)) ?? ""));
+}
+var test_read_map = {
+  MAP_VERSION,
+  changed_since_tree,
+  collect_records,
+  in_unread_directory,
+  map_path,
+  merge_records,
+  parse_map,
+  read_map,
+  readers_of,
+  write_map
+};
+
+export {
+  test_read_trace,
+  test_read_map
+};