@joshuafolkken/kit 1.3041.0 → 1.3092.0

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

@@ -0,0 +1,333 @@
+import {
+  MERGED_STATE,
+  git_gh_helpers,
+  to_gh_state
+} from "./chunk-IAGENI2U.js";
+import {
+  git_gh_issue_memo
+} from "./chunk-IPS7EBE5.js";
+import {
+  rest_comment_schema
+} from "./chunk-34DND4BA.js";
+import {
+  FULL_PAGE_QUERY,
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  gh_failure,
+  git_gh_exec,
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/gh/git-gh-comments-unreadable.ts
+var UNREADABLE_COMMENTS_STOP = "the merge gate stopped on reviewer comments it could not read";
+var RETRY_PENDING_KEY = "JOSH_SHIP_RETRY_PENDING";
+var RETRY_PENDING_VALUE = "1";
+function note_unreadable_comments(branch_name, reason) {
+  console.warn(`\u26A0 pull request comments could not be read for ${branch_name}: ${reason}`);
+}
+function note_unreadable_stop() {
+  console.info(`\u26A0\uFE0F ${UNREADABLE_COMMENTS_STOP}`);
+}
+function is_retry_pending() {
+  return process.env[RETRY_PENDING_KEY] === RETRY_PENDING_VALUE;
+}
+
+// scripts/gh/git-gh-pr-rest.ts
+import { z } from "zod";
+var rest_repo_schema = z.looseObject({ full_name: z.string().optional() }).nullish();
+var rest_pull_side_schema = z.looseObject({ ref: z.string().optional(), repo: rest_repo_schema });
+var rest_pull_schema = z.looseObject({
+  number: z.number(),
+  html_url: z.string().optional(),
+  body: z.string().nullish(),
+  state: z.string().optional(),
+  merged: z.boolean().nullish(),
+  merged_at: z.string().nullish(),
+  mergeable: z.boolean().nullish(),
+  mergeable_state: z.string().optional(),
+  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
+  // REST hangs the check runs and the status contexts off the commit rather than off the pull
+  // request.
+  head: z.looseObject({ ref: z.string().optional(), sha: z.string().optional(), repo: rest_repo_schema }).nullish(),
+  base: rest_pull_side_schema.nullish(),
+  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
+  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
+  node_id: z.string().optional(),
+  auto_merge: z.looseObject({}).nullish()
+});
+var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
+var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
+var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
+var OPEN_STATE = "open";
+var EMPTY_BODY = "";
+function parse_rest_pull(rest_json) {
+  const parsed = parse_json_object_or_undefined(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
+  return parsed;
+}
+function parse_rest_pulls(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
+  return parsed;
+}
+function select_pull(pulls) {
+  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
+}
+function is_merged(pull) {
+  return pull.merged === true || typeof pull.merged_at === "string";
+}
+function to_pr_state(pull) {
+  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
+}
+function to_repo_name(side) {
+  return side?.repo?.full_name;
+}
+function is_same_repository_head(pull) {
+  const head_repo = to_repo_name(pull.head);
+  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
+}
+function to_pr_info(pull) {
+  return {
+    mergeable: pull.mergeable,
+    mergeStateStatus: to_gh_state(pull.mergeable_state),
+    state: to_pr_state(pull)
+  };
+}
+function to_pr_comments(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
+  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
+  return parsed.map((comment) => ({
+    body: comment.body ?? EMPTY_BODY,
+    url: comment.html_url,
+    author: { login: comment.user?.login },
+    updatedAt: comment.updated_at
+  }));
+}
+var git_gh_pr_rest = {
+  parse_rest_pull,
+  parse_rest_pulls,
+  select_pull,
+  is_same_repository_head,
+  is_merged,
+  to_pr_state,
+  to_pr_info,
+  to_pr_comments
+};
+
+// scripts/gh/git-gh-pr-too-large.ts
+var UNPROCESSABLE_STATUS = 422;
+var TOO_MANY_FILES_TEXT = "too many files changed";
+function is_too_many_files(error) {
+  if (gh_failure.failure_of(error)?.status !== UNPROCESSABLE_STATUS) return false;
+  return error_text.message_of(error).includes(TOO_MANY_FILES_TEXT);
+}
+var git_gh_pr_too_large = { is_too_many_files };
+
+// scripts/gh/git-gh-pr-read.ts
+var pr_number_by_branch = /* @__PURE__ */ new Map();
+var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
+var COMMENTS_QUERY = FULL_PAGE_QUERY;
+var OWNER_PLACEHOLDER = "{owner}";
+var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
+var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
+function lookup_path(branch_name) {
+  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
+  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
+}
+async function fetch_branch_pull(branch_name) {
+  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
+  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json));
+}
+async function fetch_pr_number(branch_name) {
+  const pull = await fetch_branch_pull(branch_name);
+  return pull?.number;
+}
+var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
+var pull_by_number = /* @__PURE__ */ new Map();
+async function fetch_pr_number_read(branch_name) {
+  try {
+    const pr_number = await fetch_pr_number(branch_name);
+    if (pr_number === void 0) return { kind: "missing" };
+    pr_number_by_branch.set(branch_name, pr_number);
+    return { kind: "read", pr_number };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function start_pr_number_read(branch_name) {
+  const pending = pending_pr_number_by_branch.get(branch_name);
+  if (pending !== void 0) return await pending;
+  const lookup = fetch_pr_number_read(branch_name);
+  pending_pr_number_by_branch.set(branch_name, lookup);
+  try {
+    return await lookup;
+  } finally {
+    pending_pr_number_by_branch.delete(branch_name);
+  }
+}
+function forget_pr_numbers() {
+  pr_number_by_branch.clear();
+  pending_pr_number_by_branch.clear();
+  pull_by_number.clear();
+  git_gh_issue_memo.forget();
+}
+async function read_pr_number(branch_name) {
+  const cached = pr_number_by_branch.get(branch_name);
+  if (cached !== void 0) return { kind: "read", pr_number: cached };
+  return await start_pr_number_read(branch_name);
+}
+async function resolve_pr_number(branch_name) {
+  const read = await read_pr_number(branch_name);
+  return read.kind === "read" ? read.pr_number : void 0;
+}
+function to_unreadable_error(branch_name, cause) {
+  const [gist = ""] = error_text.message_of(cause).split("\n", 1);
+  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name} (${gist})`, { cause });
+}
+async function require_pr_number(branch_name) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind === "read") return read.pr_number;
+  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
+  throw to_unreadable_error(branch_name, read.cause);
+}
+async function read_pull(pr_number) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(pr_number))
+  });
+  return git_gh_pr_rest.parse_rest_pull(json);
+}
+async function read_remembered_pull(pr_number) {
+  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
+  pull_by_number.set(pr_number, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
+    throw error;
+  }
+}
+async function read_listed_pull(detail_error, branch_name, pr_number) {
+  if (!git_gh_pr_too_large.is_too_many_files(detail_error)) return void 0;
+  const pull = await fetch_branch_pull(branch_name);
+  return pull?.number === pr_number ? pull : void 0;
+}
+async function read_pull_or_listed(branch_name, pr_number, read) {
+  try {
+    return await read(pr_number);
+  } catch (error) {
+    const listed = await read_listed_pull(error, branch_name, pr_number);
+    if (listed === void 0) throw error;
+    return listed;
+  }
+}
+async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
+  const number_read = await read_pr_number(branch_name);
+  if (number_read.kind !== "read") return number_read;
+  try {
+    return {
+      kind: "read",
+      pull: await read_pull_or_listed(branch_name, number_read.pr_number, read)
+    };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function read_pull_or_undefined(branch_name) {
+  const read = await read_pull_of_branch(branch_name);
+  return read.kind === "read" ? read.pull : void 0;
+}
+async function pr_exists(branch_name) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  return read.kind === "read";
+}
+async function pr_get_number(branch_name) {
+  return await resolve_pr_number(branch_name);
+}
+async function pr_get_url(branch_name) {
+  const pull = await read_pull_or_undefined(branch_name);
+  if (pull?.html_url === void 0) return void 0;
+  return git_gh_helpers.parse_pr_state_string(pull.html_url);
+}
+async function pr_get_merge_state(branch_name) {
+  const read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind !== "read") return void 0;
+  const { pull } = read;
+  return {
+    is_merged: git_gh_pr_rest.is_merged(pull),
+    merged_at: pull.merged_at ?? void 0,
+    head_sha: pull.head?.sha,
+    merge_state_status: to_gh_state(pull.mergeable_state)
+  };
+}
+async function pr_get_body(branch_name) {
+  const pull = await read_pull_or_undefined(branch_name);
+  const body = pull?.body;
+  return typeof body === "string" && body.length > 0 ? body : void 0;
+}
+async function pr_view(branch_name) {
+  const read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  if (read.kind === "missing") return "";
+  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull));
+}
+function unresolved_reason(read) {
+  return read.kind === "unreadable" ? error_text.message_of(read.cause) : NO_PULL_REQUEST_MESSAGE;
+}
+async function read_comments(branch_name, to_path, to_json) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind !== "read") {
+    note_unreadable_comments(branch_name, unresolved_reason(read));
+    return void 0;
+  }
+  const path = `${to_path(String(read.pr_number))}${COMMENTS_QUERY}`;
+  try {
+    return to_json(await git_gh_exec.exec_gh_api({ path, should_paginate: true }));
+  } catch (error) {
+    note_unreadable_comments(branch_name, error_text.message_of(error));
+    return void 0;
+  }
+}
+function to_comments_json(raw) {
+  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
+}
+function as_served(raw) {
+  return raw;
+}
+async function pr_get_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
+}
+async function pr_get_review_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
+}
+var git_gh_pr_read = {
+  pr_exists,
+  pr_get_number,
+  pr_get_url,
+  pr_get_body,
+  pr_get_merge_state,
+  pr_view,
+  pr_get_comments,
+  pr_get_review_comments
+};
+
+export {
+  UNREADABLE_COMMENTS_STOP,
+  RETRY_PENDING_KEY,
+  RETRY_PENDING_VALUE,
+  note_unreadable_stop,
+  is_retry_pending,
+  git_gh_pr_rest,
+  git_gh_pr_too_large,
+  forget_pr_numbers,
+  require_pr_number,
+  read_pull,
+  read_listed_pull,
+  read_pull_or_listed,
+  git_gh_pr_read
+};

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

@@ -0,0 +1,44 @@
+import {
+  run_progress_clock
+} from "./chunk-3YT3RCSI.js";
+import {
+  run_headless
+} from "./chunk-Q4ULMZAS.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/run-watcher-guard.ts
+var WATCHER_TICK_MS = 3e4;
+var TICK_MULTIPLIER = 3;
+var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND;
+var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding. It reports to the run event stream on its own and exits only when newly runnable work arrives, so start it once and relay nothing`;
+var OK_RESULT = { kind: "ok" };
+async function owes_watcher(ancestry) {
+  if (run_headless.is_headless() || !await run_headless.is_backlog_parent(process.env, ancestry)) {
+    return false;
+  }
+  return await lane_registry.has_lanes_in_flight();
+}
+async function check(life_target, ancestry = lane_reap.own_ancestry) {
+  if (!await owes_watcher(ancestry) || run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) {
+    return OK_RESULT;
+  }
+  return { kind: "stale", note: STALE_NOTE };
+}
+var run_watcher_guard = {
+  STALE_NOTE,
+  STALE_THRESHOLD_MS,
+  check
+};
+
+export {
+  run_watcher_guard
+};

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

@@ -0,0 +1,77 @@
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  git_location_environment,
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  COMMAND_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/init/start-exec.ts
+import { execaSync } from "execa";
+var SUCCESS_EXIT_CODE = 0;
+var GIT_DIRECTORY = ".git";
+var IDENTITY_VARIABLES = ["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"];
+function root_environment() {
+  return git_location_environment.location_free_environment();
+}
+function git_succeeds(args, root) {
+  return git_spawn_sync.run(args, { cwd: root, env: root_environment() }).exit_code === 0;
+}
+function git_read(args, root) {
+  return git_spawn_sync.read(args, { cwd: root, env: root_environment() });
+}
+function is_identity_refused(variable, options) {
+  const { exit_code } = git_spawn_sync.run(["var", variable], options);
+  return exit_code !== void 0 && exit_code !== SUCCESS_EXIT_CODE;
+}
+function lacks_git_identity(root, is_new_repository) {
+  const location = is_new_repository ? { GIT_DIR: GIT_DIRECTORY } : {};
+  const options = { cwd: root, env: { ...root_environment(), ...location } };
+  return IDENTITY_VARIABLES.some((variable) => is_identity_refused(variable, options));
+}
+function git_run(args, root) {
+  const options = { cwd: root, env: root_environment(), timeout: SUITE_TIMEOUT_MS };
+  const { exit_code } = git_spawn_sync.run(args, { ...options, stdio: "inherit" });
+  if (exit_code === SUCCESS_EXIT_CODE) return;
+  const outcome = exit_code === void 0 ? "did not finish" : `exited with ${String(exit_code)}`;
+  throw new Error(`git ${args.join(" ")} ${outcome}`);
+}
+function gh_probe_options(root) {
+  const environment = { ...root_environment(), ...git_gh_exec.direct_environment().env };
+  return { cwd: root, env: environment, timeout: COMMAND_TIMEOUT_MS, reject: false };
+}
+function is_gh_installed(root) {
+  const result = execaSync("gh", ["--version"], gh_probe_options(root));
+  return result.exitCode === SUCCESS_EXIT_CODE;
+}
+function is_gh_signed_in(root) {
+  const result = execaSync("gh", ["auth", "status"], gh_probe_options(root));
+  return result.exitCode === SUCCESS_EXIT_CODE;
+}
+function create_github_repository(name, visibility, root) {
+  const source = ["--source", ".", "--remote", "origin", "--push"];
+  const { env } = gh_probe_options(root);
+  const options = { cwd: root, env, timeout: SUITE_TIMEOUT_MS, stdio: "inherit" };
+  execaSync("gh", ["repo", "create", name, `--${visibility}`, ...source], options);
+}
+function run_local(command, args, root) {
+  execaSync(command, args, { cwd: root, stdio: "inherit" });
+}
+var start_exec = {
+  git_succeeds,
+  git_read,
+  git_run,
+  lacks_git_identity,
+  is_gh_installed,
+  is_gh_signed_in,
+  create_github_repository,
+  run_local
+};
+
+export {
+  start_exec
+};

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

@@ -0,0 +1,35 @@
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lib/inherited-scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function storage(key) {
+  const symbol = Symbol.for(key);
+  const existing = Reflect.get(globalThis, symbol);
+  const scope = existing instanceof AsyncLocalStorage ? existing : new AsyncLocalStorage();
+  Reflect.set(globalThis, symbol, scope);
+  return scope;
+}
+function create(key, schema) {
+  const scope = storage(key);
+  function local() {
+    return schema.safeParse(scope.getStore()).data;
+  }
+  function current() {
+    return local() ?? json_value.parse_with(process.env[key] ?? "", schema);
+  }
+  async function within(value, run) {
+    return await scope.run(value, run);
+  }
+  function environment() {
+    const value = current();
+    return value === void 0 ? {} : { [key]: JSON.stringify(value) };
+  }
+  return { current, local, within, environment };
+}
+var inherited_scope = { create };
+
+export {
+  inherited_scope
+};

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

@@ -0,0 +1,126 @@
+import {
+  cost_usage
+} from "./chunk-DDZVMXZD.js";
+
+// scripts/cost-runtime/cost-pricing.ts
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
+var HALVED_CACHE_READ_MULTIPLIER = 0.05;
+var QUARTERED_CACHE_READ_MULTIPLIER = 0.025;
+var TOKENS_PER_MILLION = 1e6;
+var LONG_PROMPT_SUFFIX = ":long-prompt";
+var LONG_PROMPT_THRESHOLD = 1e5;
+var MODEL_PRICES = {
+  "claude-fable-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-mythos-5-1": {
+    input: 10,
+    output: 50,
+    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
+  },
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5-5": { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-5-5": {
+    input: 2,
+    output: 10,
+    cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER
+  },
+  "claude-sonnet-5": { input: 2, output: 10 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-5-5": { input: 0.1, output: 0.5 },
+  [`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
+  "claude-haiku-4-5": { input: 1, output: 5 }
+};
+var CONTEXT_MARKER = "[";
+var DATE_SUFFIX = /-\d{8}$/u;
+function known_id(model) {
+  const base = model.split(CONTEXT_MARKER)[0] ?? model;
+  return [base, base.replace(DATE_SUFFIX, "")].find((id) => Object.hasOwn(MODEL_PRICES, id));
+}
+function resolve_price(model) {
+  const id = known_id(model);
+  return id === void 0 ? void 0 : MODEL_PRICES[id];
+}
+function cache_read_multiplier(price) {
+  return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER;
+}
+function cache_read_multiplier_of(model) {
+  const price = model === void 0 ? void 0 : resolve_price(model);
+  return price === void 0 ? DEFAULT_CACHE_READ_MULTIPLIER : cache_read_multiplier(price);
+}
+function estimate_cost(totals, price) {
+  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * cache_read_multiplier(price);
+  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+}
+function priced(tokens, rate) {
+  return tokens * rate / TOKENS_PER_MILLION;
+}
+function estimate_composition(totals, price) {
+  return {
+    input_usd: priced(totals.input_tokens, price.input),
+    cache_write_5m_usd: priced(
+      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
+      price.input
+    ),
+    cache_write_1h_usd: priced(
+      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
+      price.input
+    ),
+    cache_read_usd: priced(totals.cache_read_tokens * cache_read_multiplier(price), price.input),
+    output_usd: priced(totals.output_tokens, price.output)
+  };
+}
+function to_model_cost(model, totals) {
+  const price = resolve_price(model);
+  if (price === void 0) return { model, totals };
+  return { model, totals, cost_usd: estimate_cost(totals, price) };
+}
+function billed_model(usage) {
+  const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`;
+  const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD;
+  return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model;
+}
+function cost_by_model(records) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const model = billed_model(record);
+    const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS;
+    grouped.set(model, cost_usage.add_totals(running, record.totals));
+  }
+  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
+}
+function total_cost(costs) {
+  return {
+    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
+    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
+  };
+}
+function cost_of(records) {
+  return total_cost(cost_by_model(records)).usd;
+}
+var cost_pricing = {
+  CACHE_WRITE_5M_MULTIPLIER,
+  CACHE_WRITE_1H_MULTIPLIER,
+  DEFAULT_CACHE_READ_MULTIPLIER,
+  LONG_PROMPT_THRESHOLD,
+  resolve_price,
+  cache_read_multiplier_of,
+  estimate_cost,
+  estimate_composition,
+  cost_by_model,
+  total_cost,
+  cost_of
+};
+
+export {
+  cost_pricing
+};

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

@@ -0,0 +1,64 @@
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/sonar/sonar-project.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var SONAR_HOST = "https://sonarcloud.io";
+var PROPERTIES_FILE = "sonar-project.properties";
+var PROJECT_KEY_PREFIX = "sonar.projectKey=";
+var TOKEN_VARIABLE = "SONAR_TOKEN";
+var AUTHORIZATION_HEADER = "Authorization";
+function read_project_key(root) {
+  const file = path.join(root, PROPERTIES_FILE);
+  if (!existsSync(file)) return void 0;
+  const line = readFileSync(file, "utf8").split("\n").find((entry) => entry.startsWith(PROJECT_KEY_PREFIX));
+  return line?.slice(PROJECT_KEY_PREFIX.length).trim();
+}
+function api_url(api_path, query) {
+  return `${SONAR_HOST}${api_path}?${new URLSearchParams(query).toString()}`;
+}
+function request_init() {
+  const token = process.env[TOKEN_VARIABLE] ?? "";
+  return token === "" ? {} : { headers: [[AUTHORIZATION_HEADER, `Bearer ${token}`]] };
+}
+async function fetch_json(url, schema) {
+  try {
+    const response = await timed_fetch(url, request_init());
+    if (!response.ok) return { error: `HTTP ${String(response.status)}` };
+    return { data: schema.parse(await response.json()) };
+  } catch (error) {
+    return { error: error_text.message_of(error) };
+  }
+}
+async function resolve_target(argv, usage) {
+  const [pull_request] = argv;
+  if (pull_request === void 0 || pull_request.startsWith("-")) {
+    console.error(usage);
+    return void 0;
+  }
+  const project_key = read_project_key(await git_command.repository_root());
+  if (project_key === void 0) {
+    console.error(`no ${PROJECT_KEY_PREFIX} found in ${PROPERTIES_FILE}`);
+    return void 0;
+  }
+  return { project_key, pull_request };
+}
+var sonar_project = {
+  api_url,
+  fetch_json,
+  read_project_key,
+  request_init,
+  resolve_target
+};
+
+export {
+  sonar_project
+};