@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-AV26CMY6.js

@@ -1,304 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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
-};