@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-OX3VQLV2.js

@@ -1,488 +0,0 @@
-import {
-  issue_sample_prime
-} from "./chunk-QDFVVRQP.js";
-import {
-  epic_issue
-} from "./chunk-IAD4WLLI.js";
-import {
-  propagate_publish
-} from "./chunk-JAKC2BHX.js";
-import {
-  derive_versions_endpoint
-} from "./chunk-SADJPNDB.js";
-import {
-  git_gh_issue_batch_graphql,
-  git_gh_issue_batch_read
-} from "./chunk-EXDFKKMH.js";
-import {
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  shared_cache
-} from "./chunk-C6QSVO5K.js";
-import {
-  author_fields_schema
-} from "./chunk-34DND4BA.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  repo_map_logic
-} from "./chunk-MDKDJF2K.js";
-import {
-  repo_origin
-} from "./chunk-4ZHWTTQW.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  GH_API_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/epic/epic-cross-repo.ts
-import { load } from "js-yaml";
-function package_name_for(repo) {
-  const identity = repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${repo}`);
-  if (identity === void 0) return void 0;
-  return `@${identity.owner}/${identity.repo}`;
-}
-var published_cache = /* @__PURE__ */ new Map();
-function fetch_versions_for(repo) {
-  const package_name = package_name_for(repo);
-  if (package_name === void 0) return void 0;
-  return propagate_publish.fetch_published_versions(derive_versions_endpoint(package_name));
-}
-function published_versions(repo) {
-  if (published_cache.has(repo)) return published_cache.get(repo);
-  const versions = fetch_versions_for(repo);
-  published_cache.set(repo, versions);
-  return versions;
-}
-var version_cache = /* @__PURE__ */ new Map();
-function reset_publish_cache() {
-  published_cache.clear();
-  version_cache.clear();
-}
-function is_published(repo, version) {
-  const versions = published_versions(repo);
-  if (versions === void 0) return false;
-  return propagate_publish.is_version_published(versions, version);
-}
-var VERSION_JQ = ".content | @base64d | fromjson | {version, private, workspaces} | tojson";
-var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
-var WORKSPACE_JQ = ".content | @base64d";
-var NOT_FOUND_STATUS = 404;
-function manifest_path(repo) {
-  return `${git_gh_api_path.repo_api_path(repo)}/contents/package.json`;
-}
-function declares_packages(yaml) {
-  try {
-    const parsed = load(yaml);
-    if (typeof parsed !== "object" || parsed === null) return false;
-    const { packages } = parsed;
-    return Array.isArray(packages) && packages.length > 0;
-  } catch {
-    return false;
-  }
-}
-function pnpm_workspace_path(repo) {
-  return `${git_gh_api_path.repo_api_path(repo)}/contents/${PNPM_WORKSPACE_FILE}`;
-}
-function classify_workspace_failure(repo) {
-  const status = git_gh_exec.exec_gh_api_status_sync(pnpm_workspace_path(repo), GH_API_TIMEOUT_MS);
-  return status === NOT_FOUND_STATUS ? "single" : "unreadable";
-}
-function read_pnpm_workspace(repo) {
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: pnpm_workspace_path(repo),
-    jq_filter: WORKSPACE_JQ,
-    timeout_ms: GH_API_TIMEOUT_MS
-  });
-  if (stdout === void 0) return classify_workspace_failure(repo);
-  return declares_packages(stdout) ? "workspace" : "single";
-}
-function declared_workspaces(declared) {
-  if (declared === void 0 || declared === null) return void 0;
-  if (Array.isArray(declared)) return declared.length > 0 ? "workspace" : "single";
-  return "workspace";
-}
-function workspace_check(repo, fields) {
-  return declared_workspaces(fields.workspaces) ?? read_pnpm_workspace(repo);
-}
-function to_answer(repo, fields) {
-  const version = typeof fields.version === "string" ? fields.version : void 0;
-  if (fields.private !== true) {
-    return { kind: "manifest", version, is_private: false, is_workspace: false };
-  }
-  const check = workspace_check(repo, fields);
-  if (check === "unreadable") return { kind: "unreadable" };
-  return { kind: "manifest", version, is_private: true, is_workspace: check === "workspace" };
-}
-function to_manifest(repo, stdout) {
-  const parsed = json_value.parse_or_undefined(stdout.trim());
-  if (typeof parsed !== "object" || parsed === null) return { kind: "unreadable" };
-  return to_answer(repo, parsed);
-}
-function classify_manifest_failure(repo) {
-  const status = git_gh_exec.exec_gh_api_status_sync(manifest_path(repo), GH_API_TIMEOUT_MS);
-  return { kind: status === NOT_FOUND_STATUS ? "absent" : "unreadable" };
-}
-function fetch_manifest(repo) {
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: manifest_path(repo),
-    jq_filter: VERSION_JQ,
-    timeout_ms: GH_API_TIMEOUT_MS
-  });
-  return stdout === void 0 ? classify_manifest_failure(repo) : to_manifest(repo, stdout);
-}
-function read_manifest(repo) {
-  const cached = version_cache.get(repo);
-  if (cached !== void 0) return cached;
-  const answer = fetch_manifest(repo);
-  version_cache.set(repo, answer);
-  return answer;
-}
-function read_default_branch_version(repo) {
-  const answer = read_manifest(repo);
-  return answer.kind === "manifest" ? answer.version : void 0;
-}
-function publishes_nothing(repo) {
-  const answer = read_manifest(repo);
-  if (answer.kind === "absent") return true;
-  return answer.kind === "manifest" && answer.is_private && !answer.is_workspace;
-}
-function publish_verdict(repo, version) {
-  if (publishes_nothing(repo)) return "resolved";
-  if (version === void 0) return "time";
-  return is_published(repo, version) ? "resolved" : "time";
-}
-function resolve_cross_repo(blocker, blocked, read_target_version = read_default_branch_version) {
-  if (blocker.state !== "CLOSED") return "inherit";
-  if (blocker.repo === blocked.repo) return "resolved";
-  return publish_verdict(blocker.repo, read_target_version(blocker.repo));
-}
-function owner_of(repo) {
-  return repo.split("/", 1)[0] ?? "";
-}
-function is_same_owner_repo(repo, current_owner) {
-  const identity = repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${repo}`);
-  if (identity === void 0) return false;
-  return repo_map_logic.is_same_owner(identity, current_owner);
-}
-var epic_cross_repo = {
-  publishes_nothing,
-  read_default_branch_version,
-  reset_publish_cache,
-  package_name_for,
-  resolve_cross_repo,
-  owner_of,
-  is_same_owner_repo
-};
-
-// scripts/epic/epic-child-source.ts
-import { z } from "zod";
-var HOURS_KEPT = 6;
-var MS_PER_HOUR = 36e5;
-var CLOSED_CACHE = { prefix: "josh-epic-closed-", ttl_ms: HOURS_KEPT * MS_PER_HOUR };
-var reference_schema = z.object({ repo: z.string(), number: z.number() });
-var child_schema = z.object({
-  number: z.number(),
-  repo: z.string(),
-  state: z.enum(["OPEN", "CLOSED"]),
-  labels: z.array(z.string()),
-  blocked_by: z.array(reference_schema),
-  body: z.string().optional(),
-  ...author_fields_schema
-});
-var entries_schema = z.array(z.object({ read_at: z.number(), child: child_schema }));
-function fresh_entries(repo, now_ms) {
-  const entries = shared_cache.read(CLOSED_CACHE, repo, entries_schema, now_ms) ?? [];
-  return entries.filter((entry) => now_ms - entry.read_at < CLOSED_CACHE.ttl_ms);
-}
-function cached_closed(repo, now_ms) {
-  return new Map(fresh_entries(repo, now_ms).map((entry) => [entry.child.number, entry.child]));
-}
-function known(source, repo, now_ms) {
-  if (source === void 0) return /* @__PURE__ */ new Map();
-  const closed = cached_closed(repo, now_ms);
-  return source.repo === repo ? new Map([...closed, ...source.listed]) : closed;
-}
-function is_closed(child) {
-  return child.state === epic_issue.CLOSED;
-}
-function remember_closed(source, repo, children, now_ms) {
-  if (source === void 0) return;
-  const fresh = fresh_entries(repo, now_ms);
-  const reopened = new Set(
-    children.filter((child) => !is_closed(child)).map((child) => child.number)
-  );
-  const kept = fresh.filter((entry) => !reopened.has(entry.child.number));
-  const cached = new Set(kept.map((entry) => entry.child.number));
-  const added = children.filter((child) => is_closed(child) && !cached.has(child.number));
-  if (added.length === 0 && kept.length === fresh.length) return;
-  const entries = [...kept, ...added.map((child) => ({ read_at: now_ms, child }))];
-  shared_cache.write(CLOSED_CACHE, repo, entries, now_ms);
-}
-function waited_closed(children, known_children, repo) {
-  const waited = children.filter((child) => !is_closed(child)).flatMap((child) => child.blocked_by).filter((blocker) => blocker.repo === repo).map((blocker) => blocker.number);
-  return new Set(waited.filter((number) => known_children.get(number)?.state === epic_issue.CLOSED));
-}
-var epic_child_source = { CLOSED_CACHE, known, remember_closed, waited_closed };
-
-// scripts/epic/epic-relation-recheck.ts
-var RECHECK_LIMIT = 20;
-function suspect_children(children, body, declared_repo) {
-  const links = epic_parse.parse_dependency_links(body);
-  const local = children.filter((child) => child.repo === declared_repo);
-  return new Set(
-    epic_graph.missing_relations(links, local, declared_repo).map((link) => link.blocked)
-  );
-}
-async function reread_child(child, read_blockers) {
-  try {
-    return { ...child, blocked_by: await read_blockers(child) };
-  } catch (error) {
-    const reason = error_text.message_of(error);
-    console.warn(
-      `\u26A0 could not re-read the blockers of ${session_cite.issue(child.number, void 0, child.repo)}: ${reason}
-  a mismatch reported below may be this read failing rather than a missing relation`
-    );
-    return child;
-  }
-}
-function skipped_over_limit(children, suspect_count) {
-  console.warn(
-    `\u26A0 ${String(suspect_count)} declared links are unrecorded, past the ${String(RECHECK_LIMIT)} this re-reads
-  the mismatch below is reported from the first read; the body is likely ahead of the relations`
-  );
-  return children;
-}
-async function recheck_missing_relations(children, body, declared_repo, read_blockers) {
-  const suspects = suspect_children(children, body, declared_repo);
-  if (suspects.size === 0) return children;
-  if (suspects.size > RECHECK_LIMIT) return skipped_over_limit(children, suspects.size);
-  return await Promise.all(
-    children.map(
-      async (child) => suspects.has(child.number) && child.repo === declared_repo ? await reread_child(child, read_blockers) : child
-    )
-  );
-}
-var epic_relation_recheck = { recheck_missing_relations, RECHECK_LIMIT };
-
-// scripts/epic/epic-fetch.ts
-var CHILD_LIMIT = 200;
-function to_child(parsed, repo) {
-  return {
-    number: parsed.number,
-    repo,
-    state: epic_issue.normalize_state(parsed.state),
-    labels: epic_issue.label_names(parsed),
-    blocked_by: epic_issue.blocker_references_of(parsed, repo),
-    body: parsed.body,
-    author_association: parsed.author_association,
-    user: parsed.user
-  };
-}
-function scope_for(child_repo, current_repo) {
-  return child_repo === current_repo ? void 0 : child_repo;
-}
-async function read_child_blockers(child, current_repo) {
-  return await git_gh_command.issue_blocked_by_references(
-    String(child.number),
-    child.repo,
-    scope_for(child.repo, current_repo)
-  );
-}
-async function fetch_epic_body(epic_number, scope) {
-  const read = await git_gh_command.issue_get_body_classified(String(epic_number), scope);
-  const body = read.kind === "read" ? read.text : void 0;
-  return {
-    body,
-    body_failure: read.kind === "read" ? void 0 : read,
-    child_numbers: epic_parse.parse_task_list_issue_numbers(body),
-    external: epic_parse.parse_external_task_list_children(body)
-  };
-}
-async function rechecked_children(children, snapshot) {
-  return await epic_relation_recheck.recheck_missing_relations(
-    children,
-    snapshot.body,
-    snapshot.repo,
-    async (child) => await read_child_blockers(child, snapshot.current_repo)
-  );
-}
-function to_references(issue_numbers, repo) {
-  return issue_numbers.map((issue_number) => ({ repo, number: issue_number }));
-}
-var NOT_READ = { child: void 0, is_unreachable: false };
-async function read_rest(issue_number, scope) {
-  return await git_gh_command.issue_get_state_and_relations_classified(String(issue_number), scope);
-}
-async function to_child_read(read, repo) {
-  if (read.kind !== "read") {
-    return { child: void 0, is_unreachable: git_gh_command.is_unreachable_read(read) };
-  }
-  const parsed = epic_issue.parse_epic_issue(read.json);
-  await issue_sample_prime.prime([parsed?.body]);
-  return { child: parsed === void 0 ? void 0 : to_child(parsed, repo), is_unreachable: false };
-}
-async function read_children(issue_numbers, repo, scope) {
-  const reads = await git_gh_issue_batch_read.read_each(issue_numbers, {
-    repo: scope,
-    from_json: git_gh_issue_batch_graphql.answered,
-    read_rest: async (issue_number) => await read_rest(issue_number, scope)
-  });
-  const entries = await Promise.all(
-    reads.map(async ([issue_number, read]) => [
-      issue_number,
-      await to_child_read(read, repo)
-    ])
-  );
-  return new Map(entries);
-}
-async function fetch_child(issue_number, repo, scope) {
-  const read = await to_child_read(await read_rest(issue_number, scope), repo);
-  return read.child;
-}
-function to_children(reads) {
-  return reads.map((read) => read.child).filter((child) => child !== void 0);
-}
-function count_unreachable(reads) {
-  return reads.filter((read) => read.is_unreachable).length;
-}
-function is_body_unreachable(failure) {
-  return failure !== void 0 && git_gh_command.is_unreachable_read(failure);
-}
-async function known_or_read(issue_number, known2, fresh) {
-  const child = known2.get(issue_number);
-  if (child === void 0) return fresh.get(issue_number) ?? NOT_READ;
-  await issue_sample_prime.prime([child.body]);
-  return { child, is_unreachable: false };
-}
-async function answer_children(issue_numbers, known2, repo, scope) {
-  const unknown = issue_numbers.filter((issue_number) => !known2.has(issue_number));
-  const fresh = await read_children(unknown, repo, scope);
-  return await Promise.all(
-    issue_numbers.map(async (issue_number) => await known_or_read(issue_number, known2, fresh))
-  );
-}
-async function recheck_blockers(reads, child_numbers, known2, repo) {
-  const waited = epic_child_source.waited_closed(to_children(reads), known2, repo);
-  if (waited.size === 0) return reads;
-  const fresh = await read_children([...waited], repo);
-  return reads.map((read, index) => fresh.get(child_numbers[index] ?? 0) ?? read);
-}
-async function fetch_children(child_numbers, repo, scope, source) {
-  const limited = child_numbers.slice(0, CHILD_LIMIT);
-  const now_ms = Date.now();
-  const known2 = epic_child_source.known(source, repo, now_ms);
-  const answered = await answer_children(limited, known2, repo, scope);
-  const reads = await recheck_blockers(answered, limited, known2, repo);
-  epic_child_source.remember_closed(source, repo, to_children(reads), now_ms);
-  return {
-    children: to_children(reads),
-    unreadable: to_references(
-      limited.filter((_, index) => reads[index]?.child === void 0),
-      repo
-    ),
-    skipped: to_references(child_numbers.slice(CHILD_LIMIT), repo),
-    unreachable_count: count_unreachable(reads)
-  };
-}
-async function read_external(allowed) {
-  const repos = [...new Set(allowed.map((child) => child.repo))];
-  const batches = await Promise.all(
-    repos.map(async (repo) => {
-      const issue_numbers = allowed.filter((child) => child.repo === repo).map((child) => child.number);
-      return await read_children(issue_numbers, repo, repo);
-    })
-  );
-  return allowed.map((child) => batches[repos.indexOf(child.repo)]?.get(child.number) ?? NOT_READ);
-}
-async function fetch_external_children(external, current_owner) {
-  const allowed = external.filter(
-    (child) => epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
-  );
-  const reads = await read_external(allowed);
-  const refused = external.filter(
-    (child) => !epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
-  );
-  return {
-    children: to_children(reads),
-    unreadable: [...allowed.filter((_, index) => reads[index]?.child === void 0), ...refused],
-    skipped: [],
-    // A refusal is not a transport failure: the owner restriction answers the same tomorrow.
-    unreachable_count: count_unreachable(reads)
-  };
-}
-function to_failure_counts(body_failure, groups) {
-  const body_failed = body_failure === void 0 ? 0 : 1;
-  return {
-    failed: body_failed + groups.reduce((total, group) => total + group.unreadable.length, 0),
-    unreachable: (is_body_unreachable(body_failure) ? 1 : 0) + groups.reduce((total, group) => total + group.unreachable_count, 0)
-  };
-}
-function is_snapshot_unreachable(body_failure, groups) {
-  const counts = to_failure_counts(body_failure, groups);
-  return counts.failed > 0 && counts.failed === counts.unreachable;
-}
-async function to_snapshot(epic_body, scope, local, remote) {
-  const { body, body_failure, child_numbers, external } = epic_body;
-  const children = await rechecked_children([...local.children, ...remote.children], {
-    body,
-    ...scope
-  });
-  return {
-    body,
-    repo: scope.repo,
-    current_repo: scope.current_repo,
-    children,
-    child_numbers: [...child_numbers, ...external.map((child) => child.number)],
-    unreadable: [...local.unreadable, ...remote.unreadable],
-    skipped: local.skipped,
-    has_external_children: external.length > 0,
-    body_failure,
-    is_unreachable: is_snapshot_unreachable(body_failure, [local, remote])
-  };
-}
-async function fetch_epic(epic_number, repo, current_repo = repo, source) {
-  const scope = scope_for(repo, current_repo);
-  const epic_body = await fetch_epic_body(epic_number, scope);
-  const owner = epic_cross_repo.owner_of(current_repo);
-  const local = await fetch_children(epic_body.child_numbers, repo, scope, source);
-  const remote = await fetch_external_children(epic_body.external, owner);
-  return await to_snapshot(epic_body, { repo, current_repo }, local, remote);
-}
-function missing_children(snapshot) {
-  return [...snapshot.unreadable, ...snapshot.skipped];
-}
-var epic_fetch = {
-  CHILD_LIMIT,
-  scope_for,
-  read_child_blockers,
-  missing_children,
-  fetch_child,
-  fetch_children,
-  fetch_external_children,
-  fetch_epic
-};
-
-export {
-  epic_cross_repo,
-  epic_fetch
-};

package/dist/commands/chunk-OZJP77UM.js

@@ -1,103 +0,0 @@
-import {
-  epic_add_body,
-  epic_chains,
-  epic_read,
-  epic_shape
-} from "./chunk-XPBF5DG3.js";
-import {
-  epic_sections
-} from "./chunk-XSKB6ZUA.js";
-import {
-  epic_relations
-} from "./chunk-FQGWO2ZH.js";
-import {
-  epic_validate
-} from "./chunk-OP2RFVLS.js";
-import {
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-
-// scripts/epic/epic-untrack-plan.ts
-function touches(link, children) {
-  return children.has(link.blocker) || children.has(link.blocked);
-}
-function without_rows(body, children) {
-  const lines = epic_sections.to_body_lines(body);
-  const removed = new Set(
-    epic_sections.find_indices(
-      lines,
-      (line) => epic_parse.parse_task_list_issue_numbers(line).some((child) => children.has(child))
-    )
-  );
-  return lines.lines.filter((_line, index) => !removed.has(index)).join("\n");
-}
-function rewrite(reading, children) {
-  const chains = epic_parse.parse_dependency_chains(reading.subject.body);
-  const removed = epic_chains.links_of(chains).filter((link) => touches(link, children));
-  return epic_add_body.rewrite_body({
-    body: without_rows(reading.subject.body ?? "", children),
-    placed: [],
-    chains_after: epic_chains.remove_links(chains, removed),
-    does_clear_declaration: removed.length > 0
-  });
-}
-function build_plan(reading, children) {
-  const tracked = epic_parse.parse_task_list_issue_numbers(reading.subject.body);
-  const error = epic_shape.find_subject_error(
-    { ...reading.subject, epic_number: reading.subject.number },
-    tracked
-  );
-  if (error !== void 0) return { error };
-  const selected = new Set(children);
-  const rewritten = rewrite(reading, selected);
-  if ("error" in rewritten) return rewritten;
-  const results = epic_validate.validate_epic({ ...reading.subject, body: rewritten.body });
-  if (!epic_validate.is_epic_valid(results)) {
-    return { error: "The remaining body would fail epic:check; nothing was written." };
-  }
-  return {
-    plan: {
-      body: rewritten.body,
-      removed: epic_graph.undeclared_relations([], reading.recorded, reading.repo).filter((link) => touches(link, selected))
-    }
-  };
-}
-var epic_untrack_plan = { build_plan };
-
-// scripts/epic/epic-untrack.ts
-var FAILURE = 1;
-var SUCCESS = 0;
-function refuse(error) {
-  console.error(`\u2716 ${error}`);
-  return FAILURE;
-}
-async function untrack(epic_number, children) {
-  const reading = await epic_read.read_epic(epic_number);
-  if ("error" in reading) return refuse(reading.error);
-  const outcome = epic_untrack_plan.build_plan(reading, children);
-  if ("error" in outcome) return refuse(outcome.error);
-  const failures = await epic_relations.apply_relations(outcome.plan.removed, "drop");
-  console.info(
-    epic_relations.format_relation_report({
-      failures,
-      links: outcome.plan.removed,
-      action: "drop"
-    })
-  );
-  if (failures > 0) return FAILURE;
-  if (outcome.plan.body !== reading.subject.body) {
-    await git_gh_command.issue_edit_body(String(epic_number), outcome.plan.body);
-  }
-  return SUCCESS;
-}
-var epic_untrack = { untrack };
-
-export {
-  epic_untrack
-};