@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-736NECRD.js

@@ -1,16 +0,0 @@
-import {
-  git_gh_issue_write
-} from "./chunk-4F4KARQN.js";
-
-// scripts/issue/issue-park.ts
-async function apply(issue, label, body) {
-  const is_labelled = await git_gh_issue_write.issue_add_label(issue, label);
-  if (!is_labelled) return { is_labelled, is_commented: false };
-  const is_commented = await git_gh_issue_write.issue_try_comment(issue, body);
-  return { is_labelled, is_commented };
-}
-var issue_park = { apply };
-
-export {
-  issue_park
-};

package/dist/commands/chunk-77LEKVEE.js

@@ -1,32 +0,0 @@
-import {
-  time_transcript_line
-} from "./chunk-YSLGWRQN.js";
-import {
-  cost_blocks,
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-
-// scripts/rules/tail-commands.ts
-function is_bash_use(block) {
-  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
-}
-function bash_commands_of(line) {
-  const parsed = time_transcript_line.parse_line(line);
-  if (parsed === void 0) return [];
-  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
-}
-function prior_bash_commands(tail) {
-  return tail.split("\n").flatMap((line) => bash_commands_of(line));
-}
-function answered(text, is_call, token) {
-  const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks);
-  const call_ids = new Set(
-    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
-  );
-  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
-}
-var tail_commands = { answered, is_bash_use, prior_bash_commands };
-
-export {
-  tail_commands
-};

package/dist/commands/chunk-7DGHFBU7.js

@@ -1,247 +0,0 @@
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/security/security-audit-logic.ts
-import path from "node:path";
-var BINARY_NAME = "osv-scanner";
-var LOCKFILE_PATH = "pnpm-lock.yaml";
-var MANAGED_TOOL_SEGMENTS = ["node_modules", ".cache", "josh-tools"];
-var WINDOWS_PLATFORM = "win32";
-var WINDOWS_BINARY_SUFFIX = ".exe";
-var INSTALL_INSTRUCTIONS = [
-  "",
-  "Install options:",
-  "  Managed: pnpm josh audit:provision",
-  "  macOS:  brew install osv-scanner",
-  "  Go:     go install github.com/google/osv-scanner/v2/cmd/osv-scanner@latest",
-  '  Docker: docker run --rm -v "$PWD:/src" ghcr.io/google/osv-scanner --lockfile=/src/pnpm-lock.yaml',
-  "",
-  "Docs: https://google.github.io/osv-scanner/"
-].join("\n");
-function build_scanner_arguments(lockfile_path) {
-  return [`--lockfile=${lockfile_path}`];
-}
-function build_managed_binary_path(project_root, platform) {
-  const suffix = platform === WINDOWS_PLATFORM ? WINDOWS_BINARY_SUFFIX : "";
-  return path.join(project_root, ...MANAGED_TOOL_SEGMENTS, `${BINARY_NAME}${suffix}`);
-}
-function format_missing_binary_error(binary_name) {
-  return `${binary_name} is not installed.
-${INSTALL_INSTRUCTIONS}`;
-}
-var security_audit_logic = {
-  BINARY_NAME,
-  LOCKFILE_PATH,
-  build_managed_binary_path,
-  build_scanner_arguments,
-  format_missing_binary_error
-};
-
-// scripts/security/security-audit-provision-logic.ts
-var SCANNER_VERSION = "2.6.0";
-var MINIMUM_SCANNER_VERSION = SCANNER_VERSION;
-var RELEASE_BASE_URL = "https://github.com/google/osv-scanner/releases/download";
-var WINDOWS_PLATFORM2 = "win32";
-var WINDOWS_ASSET_SUFFIX = ".exe";
-var SESSION_DOWNLOAD_TIMEOUT_MS = 6e4;
-var FORCED_DOWNLOAD_TIMEOUT_MS = 6e5;
-function build_download_timeout(is_forced) {
-  return is_forced ? FORCED_DOWNLOAD_TIMEOUT_MS : SESSION_DOWNLOAD_TIMEOUT_MS;
-}
-var MS_PER_HOUR = 36e5;
-var HOURS_BEFORE_RETRY = 6;
-var RETRY_INTERVAL_MS = HOURS_BEFORE_RETRY * MS_PER_HOUR;
-var PLATFORM_NAMES = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows"
-};
-var ARCHITECTURE_NAMES = {
-  arm64: "arm64",
-  x64: "amd64"
-};
-var ASSET_CHECKSUMS = {
-  "osv-scanner_darwin_amd64": "60c5296637e977b28eeda5c7f13573e447659a632922737f94d11fa7e30ad6ca",
-  "osv-scanner_darwin_arm64": "98c460dcd37de25819babd757d04542045b6243113e209edcd4d89fedb0256b4",
-  "osv-scanner_linux_amd64": "ca69b3d3cd08f889a49dc0a383122f71cc528b83803671df5fd874d97485b108",
-  "osv-scanner_linux_arm64": "2c71403eb443d05891c4f268c3ad771cf4f16e5443463fd7851ef8f454d3c7e4",
-  "osv-scanner_windows_amd64.exe": "e0ed7644118b717b028c249ee9d3515024e55e8510747ca08906eb96765354d6",
-  "osv-scanner_windows_arm64.exe": "ca1379da0e408279ef2c85cde0846a903495738a91c7b065a208048437c1686c"
-};
-function build_asset_name(platform, architecture) {
-  const platform_name = PLATFORM_NAMES[platform];
-  const architecture_name = ARCHITECTURE_NAMES[architecture];
-  if (platform_name === void 0 || architecture_name === void 0) return void 0;
-  const suffix = platform === WINDOWS_PLATFORM2 ? WINDOWS_ASSET_SUFFIX : "";
-  return `${security_audit_logic.BINARY_NAME}_${platform_name}_${architecture_name}${suffix}`;
-}
-function build_download_url(asset_name) {
-  return `${RELEASE_BASE_URL}/v${SCANNER_VERSION}/${asset_name}`;
-}
-function resolve_asset(platform, architecture) {
-  const name = build_asset_name(platform, architecture);
-  if (name === void 0) return void 0;
-  const sha256 = ASSET_CHECKSUMS[name];
-  if (sha256 === void 0) return void 0;
-  return { name, sha256, url: build_download_url(name) };
-}
-function format_already_present(location) {
-  return `osv-scanner is already available (${location}); nothing to provision.`;
-}
-function format_unsupported_platform(platform, architecture) {
-  return `No pinned osv-scanner build for ${platform}/${architecture}; install it manually to run the pre-push audit.`;
-}
-function format_download_failure(url, reason) {
-  return `Could not fetch osv-scanner from ${url}: ${reason}. Run \`pnpm josh audit:provision --force\` to retry with a longer timeout; until then the pre-push audit will report the missing binary.`;
-}
-function format_checksum_mismatch(asset_name, expected, actual) {
-  return `Checksum mismatch for ${asset_name}: expected ${expected}, got ${actual}. Nothing was installed.`;
-}
-function format_installed(target_path) {
-  return `Installed osv-scanner v${SCANNER_VERSION} at ${target_path}.`;
-}
-function format_recent_failure() {
-  return `A previous attempt to provision osv-scanner failed less than ${String(HOURS_BEFORE_RETRY)} hours ago; not retrying at session start. Run \`pnpm josh audit:provision --force\` to try again now.`;
-}
-function format_provision_error(reason) {
-  return `Could not provision osv-scanner: ${reason}. The pre-push audit will report the missing binary.`;
-}
-var SCANNER_VERSION_PATTERN = /osv-scanner version:\s*(\d+\.\d+\.\d+)/u;
-function parse_scanner_version(version_output) {
-  return SCANNER_VERSION_PATTERN.exec(version_output)?.[1];
-}
-function to_version_parts(version) {
-  return version.split(".").map(Number);
-}
-function compare_versions(left, right) {
-  const left_parts = to_version_parts(left);
-  const right_parts = to_version_parts(right);
-  const length = Math.max(left_parts.length, right_parts.length);
-  for (let index = 0; index < length; index += 1) {
-    const difference = (left_parts[index] ?? 0) - (right_parts[index] ?? 0);
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
-function meets_version_floor(version) {
-  return compare_versions(version, MINIMUM_SCANNER_VERSION) >= 0;
-}
-function format_below_floor(version) {
-  return `osv-scanner ${version} is below the required v${MINIMUM_SCANNER_VERSION}; older builds parse only part of pnpm-lock.yaml, so a clean result here is not proof the lockfile is clean. Run \`pnpm josh audit:provision --force\` to install v${SCANNER_VERSION}.`;
-}
-var security_audit_provision_logic = {
-  RETRY_INTERVAL_MS,
-  SESSION_DOWNLOAD_TIMEOUT_MS,
-  SCANNER_VERSION,
-  MINIMUM_SCANNER_VERSION,
-  build_asset_name,
-  build_download_timeout,
-  build_download_url,
-  format_already_present,
-  format_below_floor,
-  format_checksum_mismatch,
-  format_download_failure,
-  format_installed,
-  format_provision_error,
-  format_recent_failure,
-  format_unsupported_platform,
-  meets_version_floor,
-  parse_scanner_version,
-  resolve_asset
-};
-
-// scripts/security/security-audit.ts
-import { accessSync, constants, statSync } from "node:fs";
-import path2 from "node:path";
-import { execaSync } from "execa";
-var FAILURE_EXIT_CODE = 1;
-var GIT_DIRECTORY_NAME = ".git";
-var UNKNOWN_VERSION = "unknown";
-function is_binary_available(binary_name) {
-  const result = execaSync(binary_name, ["--version"], { stdio: "ignore", reject: false });
-  return result.exitCode !== void 0;
-}
-function scanner_version(binary_or_path) {
-  const result = execaSync(binary_or_path, ["--version"], { reject: false });
-  if (result.exitCode === void 0) return void 0;
-  return security_audit_provision_logic.parse_scanner_version(result.stdout);
-}
-function meets_floor(binary_or_path) {
-  const version = scanner_version(binary_or_path);
-  return version !== void 0 && security_audit_provision_logic.meets_version_floor(version);
-}
-function is_executable_file(candidate_path) {
-  try {
-    accessSync(candidate_path, constants.X_OK);
-    const stats = statSync(candidate_path);
-    return stats.isFile() && stats.size > 0;
-  } catch {
-    return false;
-  }
-}
-function managed_root(project_root) {
-  const common = git_common_directory.repository(project_root);
-  if (common === void 0 || path2.basename(common) !== GIT_DIRECTORY_NAME) return project_root;
-  return path2.dirname(common);
-}
-function managed_binary_path(project_root, platform) {
-  return security_audit_logic.build_managed_binary_path(managed_root(project_root), platform);
-}
-function managed_scanner(project_root, platform) {
-  const managed_path = managed_binary_path(project_root, platform);
-  return is_executable_file(managed_path) && meets_floor(managed_path) ? managed_path : void 0;
-}
-function resolve_scanner(project_root, platform) {
-  const { BINARY_NAME: BINARY_NAME2 } = security_audit_logic;
-  const has_path_binary = is_binary_available(BINARY_NAME2);
-  if (has_path_binary && meets_floor(BINARY_NAME2)) {
-    return { path: BINARY_NAME2, is_below_floor: false };
-  }
-  const managed = managed_scanner(project_root, platform);
-  if (managed !== void 0) return { path: managed, is_below_floor: false };
-  return has_path_binary ? { path: BINARY_NAME2, is_below_floor: true } : void 0;
-}
-var FORWARDED_OUTPUT = ["inherit", "pipe"];
-function run_scanner(scanner_path) {
-  const { LOCKFILE_PATH: LOCKFILE_PATH2, build_scanner_arguments: build_scanner_arguments2 } = security_audit_logic;
-  const result = execaSync(scanner_path, [...build_scanner_arguments2(LOCKFILE_PATH2)], {
-    stdin: "inherit",
-    stdout: FORWARDED_OUTPUT,
-    stderr: FORWARDED_OUTPUT,
-    reject: false
-  });
-  return result.exitCode ?? FAILURE_EXIT_CODE;
-}
-function warn_below_floor(scanner_path) {
-  const version = scanner_version(scanner_path) ?? UNKNOWN_VERSION;
-  console.warn(security_audit_provision_logic.format_below_floor(version));
-}
-function run() {
-  const { BINARY_NAME: BINARY_NAME2, format_missing_binary_error: format_missing_binary_error2 } = security_audit_logic;
-  const choice = resolve_scanner(PROJECT_ROOT, process.platform);
-  if (choice === void 0) {
-    console.error(format_missing_binary_error2(BINARY_NAME2));
-    return FAILURE_EXIT_CODE;
-  }
-  if (choice.is_below_floor) warn_below_floor(choice.path);
-  return run_scanner(choice.path);
-}
-var security_audit = {
-  is_binary_available,
-  is_executable_file,
-  managed_binary_path,
-  meets_floor,
-  resolve_scanner,
-  run,
-  run_scanner
-};
-
-export {
-  security_audit_logic,
-  security_audit_provision_logic,
-  security_audit
-};

package/dist/commands/chunk-7EAYFMDN.js

@@ -1,235 +0,0 @@
-import {
-  repository_lock
-} from "./chunk-NUCFIYZL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  lane_state_record
-} from "./chunk-UUH3DE77.js";
-import {
-  durable_state,
-  run_carry
-} from "./chunk-DS53UUDH.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-state.ts
-import { readdirSync } from "node:fs";
-import path from "node:path";
-
-// scripts/lib/figure-format.ts
-var USD_DECIMALS = 4;
-var PERCENT_SCALE = 100;
-var PERCENT_DECIMALS = 1;
-var MINUTE_DECIMALS = 1;
-var CLOCK_WIDTH = 2;
-var CLOCK_PAD = "0";
-function format_usd(usd, decimals = USD_DECIMALS) {
-  return `$${usd.toFixed(decimals)}`;
-}
-function format_tokens(count) {
-  return count.toLocaleString("en-US");
-}
-function format_share(part, whole) {
-  if (whole === 0) return "n/a";
-  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
-}
-function format_minutes(duration_ms) {
-  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
-}
-function two_digits(value) {
-  return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD);
-}
-function clock_of(ms) {
-  const date = new Date(ms);
-  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((value) => two_digits(value)).join(":");
-}
-function minute_of(ms) {
-  const date = new Date(ms);
-  return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(":");
-}
-var figure_format = {
-  format_usd,
-  format_tokens,
-  format_share,
-  format_minutes,
-  two_digits,
-  clock_of,
-  minute_of
-};
-
-// scripts/lane/lane-state.ts
-var LOCK_SUFFIX = ".lock";
-var LOCK_WAIT_MS = 5e3;
-var { HUMAN_REVIEW, LANE_STATES, STATE_SUFFIX } = lane_state_record;
-var NO_STATE_HINT = "no lane state \u2014 counted in use";
-var TRANSITIONS = {
-  open: ["open", "running", "paused", HUMAN_REVIEW, "ended"],
-  running: ["running", "paused", HUMAN_REVIEW, "ended"],
-  paused: ["paused", "running", "ended"],
-  [HUMAN_REVIEW]: [HUMAN_REVIEW, "running", "ended"],
-  ended: ["ended", "open"]
-};
-function state_path(directory, issue) {
-  return path.join(
-    durable_state.ensure(durable_state.root()),
-    lane_state_record.record_name(directory, issue)
-  );
-}
-function is_allowed(from, to) {
-  return from === void 0 || TRANSITIONS[from].includes(to);
-}
-function read_record(directory, issue) {
-  return lane_state_record.read_record_file(state_path(directory, issue));
-}
-function write_record(directory, record) {
-  stamp_file.replace_stamp(state_path(directory, record.issue), record);
-}
-function current_run(directory) {
-  const carried = run_carry.read_carry(run_carry.carry_path(directory));
-  if (carried.kind !== "carried") return void 0;
-  return { started_at: carried.carry.started_at, owner_pid: carried.carry.owner_pid };
-}
-function launch_fields(change, directory, now) {
-  if (change.is_launch !== true) return {};
-  return { run: current_run(directory), launched_at: now.toISOString() };
-}
-function next_record(change, previous, directory, now) {
-  if (previous?.changed_by === lane_state_record.DEPENDENCY_WAIT_COMMAND && change.is_launch === true) {
-    return previous;
-  }
-  return {
-    // An open starts a fresh life: a reopened lane keeps nothing of the run that launched it before.
-    ...change.state !== "open" && previous,
-    issue: change.issue,
-    state: change.state,
-    changed_at: now.toISOString(),
-    changed_by: change.command,
-    ...launch_fields(change, directory, now)
-  };
-}
-function apply_held(change, directory, now) {
-  const previous = read_record(directory, change.issue);
-  if (!is_allowed(previous?.state, change.state)) {
-    return { kind: "skipped", reason: `no ${previous?.state ?? ""} \u2192 ${change.state} transition` };
-  }
-  const record = next_record(change, previous, directory, now);
-  write_record(directory, record);
-  return { kind: "written", record };
-}
-var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
-function locked(directory, issue, held) {
-  const lock = `${state_path(directory, issue)}${LOCK_SUFFIX}`;
-  const outcome = repository_lock.with_lock_sync(held, lock, LOCK_WAIT_MS);
-  return outcome ?? { kind: "skipped", reason: `gave up waiting for the lock at ${lock}` };
-}
-function apply(change, directory, now) {
-  return locked(directory, change.issue, () => apply_held(change, directory, now));
-}
-function warn(change, reason) {
-  console.warn(
-    `${change.command} ${session_cite.issue(change.issue)}: lane state not recorded \u2014 ${reason}`
-  );
-}
-async function resolve_directory(directory) {
-  return directory ?? await run_carry.repository_directory();
-}
-async function outcome_of(change, options) {
-  const directory = await resolve_directory(options.directory);
-  if (directory === void 0) return NO_DIRECTORY;
-  return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
-}
-async function settled(write) {
-  try {
-    return await write();
-  } catch (error) {
-    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
-  }
-}
-async function record_change(change, options = {}) {
-  const outcome = await settled(async () => await outcome_of(change, options));
-  if (outcome.kind === "skipped") warn(change, outcome.reason);
-  return outcome;
-}
-async function read_state(issue, directory) {
-  const root = await resolve_directory(directory);
-  return root === void 0 ? void 0 : read_record(root, issue);
-}
-function recorded_issues(directory) {
-  const empty = state_path(directory, "");
-  const head = path.basename(empty).slice(0, -STATE_SUFFIX.length);
-  return readdirSync(path.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue) => issue.length > 0);
-}
-async function read_records(directory) {
-  const root = await resolve_directory(directory);
-  if (root === void 0) return [];
-  const records = recorded_issues(root).map((issue) => read_record(root, issue));
-  return records.filter((record) => record !== void 0);
-}
-function stuck_held(issue, stuck, directory) {
-  const previous = read_record(directory, issue);
-  if (previous === void 0) return { kind: "skipped", reason: "no record" };
-  const record = { ...previous, stuck };
-  write_record(directory, record);
-  return { kind: "written", record };
-}
-async function record_stuck(issue, stuck, directory) {
-  const root = await resolve_directory(directory);
-  if (root === void 0) return NO_DIRECTORY;
-  return locked(root, issue, () => stuck_held(issue, stuck, root));
-}
-function adopted_held(change, directory, now) {
-  if (read_record(directory, change.issue) !== void 0) {
-    return { kind: "skipped", reason: "a record exists" };
-  }
-  return apply_held(change, directory, now);
-}
-async function adopted_outcome(change, options) {
-  const directory = await resolve_directory(options.directory);
-  if (directory === void 0) return NO_DIRECTORY;
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  return locked(directory, change.issue, () => adopted_held(change, directory, now));
-}
-async function record_adopted(change, options = {}) {
-  return await settled(async () => await adopted_outcome(change, options));
-}
-async function read_states(issues, directory) {
-  const root = await resolve_directory(directory);
-  if (root === void 0) return /* @__PURE__ */ new Map();
-  const read = issues.map((issue) => [
-    issue,
-    read_record(root, issue)
-  ]);
-  return new Map(read.filter((entry) => entry[1] !== void 0));
-}
-function paused_text(since_ms, changed_by) {
-  return `paused since ${figure_format.minute_of(since_ms)} by ${changed_by}`;
-}
-function paused_note(record) {
-  if (record?.state !== "paused") return void 0;
-  return paused_text(Date.parse(record.changed_at), record.changed_by);
-}
-var lane_state = {
-  LANE_STATES,
-  NO_STATE_HINT,
-  is_allowed,
-  paused_note,
-  paused_text,
-  read_records,
-  read_state,
-  read_states,
-  record_adopted,
-  record_change,
-  record_stuck,
-  state_path
-};
-
-export {
-  figure_format,
-  lane_state
-};