@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-YHJ2AJMA.js

@@ -1,66 +0,0 @@
-import {
-  telegram_test
-} from "./chunk-AK7SEO4Y.js";
-import {
-  git_gh_repo
-} from "./chunk-GJYMI2CM.js";
-import {
-  run_stage
-} from "./chunk-UWLLZQJB.js";
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/issue/issue-plan-notify.ts
-var CHANGE_HEADING = /^#{2,3}\s+変更\s*$/u;
-var ANY_HEADING = /^#{1,6}\s/u;
-var TOP_LEVEL_ITEM = /^(?:[-*+]|\d+\.)\s+(?<text>\S.*)$/u;
-var SUMMARY_ITEMS = 3;
-var KICKOFF = "kickoff";
-function section_body(section) {
-  const lines = markdown_section.written_fence_free_lines(section.join("\n"));
-  const end = lines.findIndex((line) => ANY_HEADING.test(line.trim()));
-  return end === -1 ? lines : lines.slice(0, end);
-}
-function summary_of(plan) {
-  const section = markdown_section.written_section_lines_matching(
-    plan,
-    (line) => CHANGE_HEADING.test(line.trim())
-  );
-  const lines = section.length === 0 ? markdown_section.written_fence_free_lines(plan) : section_body(section);
-  const items = lines.map((line) => TOP_LEVEL_ITEM.exec(line)?.groups?.["text"]);
-  return items.filter((item) => item !== void 0).slice(0, SUMMARY_ITEMS);
-}
-function body_of(notice) {
-  const items = summary_of(notice.plan).map((item) => `- ${item}`);
-  return [...items, run_stage.next_line(KICKOFF, notice.issue_number)].join("\n");
-}
-async function slug_of(repo) {
-  return repo ?? await git_gh_repo.repo_get_name_with_owner();
-}
-async function values_of(message) {
-  const slug = await slug_of(message.repo);
-  const url = slug === void 0 ? {} : { "issue-url": issue_cite.issue_url(slug, message.issue_number) };
-  const title = message.title === void 0 ? {} : { "issue-title": message.title };
-  return { "task-type": "planning", body: message.body, ...url, ...title };
-}
-async function send_planning(message) {
-  try {
-    await telegram_test.send_values(await values_of(message));
-  } catch (error) {
-    console.error(
-      `\u26A0\uFE0F  ${message.command} could not send the planning notification: ${String(error)}`
-    );
-  }
-}
-async function send(notice) {
-  await send_planning({ ...notice, body: body_of(notice), command: "issue:plan" });
-}
-var issue_plan_notify = { summary_of, send, send_planning, slug_of };
-
-export {
-  issue_plan_notify
-};

package/dist/commands/chunk-YIA6FC3K.js

@@ -1,78 +0,0 @@
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-
-// scripts/lane/lane-paths.ts
-import path from "node:path";
-var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
-var LANE_DIRECTORY_SUFFIX = "-lanes";
-var LANE_BRANCH_SUFFIX = "-lane";
-function default_lane_root(repository_root) {
-  const name = path.basename(repository_root);
-  return path.join(path.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
-}
-function lane_root(repository_root, environment = process.env) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  return configured.length === 0 ? default_lane_root(repository_root) : path.resolve(configured);
-}
-function lane_directory(root, issue) {
-  return path.join(root, issue);
-}
-var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
-var DEFAULT_LANE_FILE_PATTERN = new RegExp(
-  String.raw`([/\\])\.([^/\\]+)${LANE_DIRECTORY_SUFFIX}[/\\]\d+(?=[/\\]|$)`,
-  "u"
-);
-function main_checkout_path(file) {
-  return file.replace(DEFAULT_LANE_FILE_PATTERN, "$1$2");
-}
-function is_lane_root(directory, environment) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  if (configured.length > 0) return path.resolve(configured) === directory;
-  return DEFAULT_LANE_ROOT_PATTERN.test(path.basename(directory));
-}
-var CLAUDE_WORKTREES_PATTERN = /[/\\]\.claude[/\\]worktrees[/\\][^/\\]+(?:[/\\].*)?$/u;
-function checkout_of(directory) {
-  return directory.replace(CLAUDE_WORKTREES_PATTERN, "");
-}
-function lane_issue_of(directory, environment = process.env) {
-  const resolved = checkout_of(path.resolve(directory));
-  const issue = path.basename(resolved);
-  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
-  return is_lane_root(path.dirname(resolved), environment) ? issue : void 0;
-}
-function lanes_root_of(checkout, environment = process.env) {
-  const resolved = checkout_of(path.resolve(checkout));
-  if (lane_issue_of(resolved, environment) === void 0) return lane_root(resolved, environment);
-  return path.dirname(resolved);
-}
-function issue_here(directory = process.cwd(), environment = process.env) {
-  const lane = lane_issue_of(directory, environment);
-  return lane === void 0 ? void 0 : Number(lane);
-}
-function lane_branch(issue) {
-  return `${issue}${LANE_BRANCH_SUFFIX}`;
-}
-var SEAT_LOCK_DIR = ".seat-locks";
-function is_lane_entry(name) {
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(name) || DEFAULT_LANE_ROOT_PATTERN.test(name);
-}
-var lane_paths = {
-  LANE_BRANCH_SUFFIX,
-  LANE_ROOT_KEY,
-  SEAT_LOCK_DIR,
-  checkout_of,
-  default_lane_root,
-  is_lane_entry,
-  issue_here,
-  lane_branch,
-  lane_directory,
-  lane_issue_of,
-  lane_root,
-  lanes_root_of,
-  main_checkout_path
-};
-
-export {
-  lane_paths
-};

package/dist/commands/chunk-YM77CF4D.js

@@ -1,183 +0,0 @@
-import {
-  run_retrospective
-} from "./chunk-QOSC5RKD.js";
-import {
-  latest_scope_cli
-} from "./chunk-EUGNQCYK.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/run/run-step.ts
-var CLOSED = "CLOSED";
-var IMPLEMENT = "implement";
-var HUMAN_REVIEW = "human-review";
-var UPDATE_DEPS = "update-deps";
-var ALREADY_DONE = "already-done";
-var KEEP_WORK = "keep-work";
-var WAIT = "wait";
-var STOP = "stop";
-var UNKNOWN = "unknown";
-var VOCABULARY = [
-  IMPLEMENT,
-  HUMAN_REVIEW,
-  UPDATE_DEPS,
-  ALREADY_DONE,
-  KEEP_WORK,
-  WAIT,
-  STOP,
-  UNKNOWN
-];
-var RETROSPECTIVE_COMMAND = "pnpm josh retrospective";
-function closed_verdict(input) {
-  return input.has_changes ? KEEP_WORK : ALREADY_DONE;
-}
-function pre_verdict(input) {
-  if (input.state === void 0) return UNKNOWN;
-  if (input.state === CLOSED) return closed_verdict(input);
-  if (input.latest_scope === latest_scope_cli.REQUIRED_SCOPE) return UPDATE_DEPS;
-  if (input.is_human_review) return HUMAN_REVIEW;
-  return IMPLEMENT;
-}
-function verdict(token) {
-  return { kind: "verdict", line: token };
-}
-function command(line) {
-  return { kind: "command", line };
-}
-function merge_command(issue_number) {
-  return command(`pnpm josh run:merge ${issue_number}`);
-}
-var KIND = run_event_stream.EVENT_KIND;
-var OFFER_BACKLOG = "pnpm josh backlog:next";
-var EVENT_ACTIONS = {
-  [KIND.PR_OPENED]: () => command("pnpm josh followup"),
-  // `ship --review` asks `review:round2 --record` itself and reuses a recorded round 1, so a run past
-  // round 1 hands the rest of the region to it rather than to the hand-run round-2 steps.
-  [KIND.REVIEW_ROUND]: () => command("pnpm josh ship --review"),
-  [KIND.MERGE]: merge_command,
-  [KIND.OUTAGE]: merge_command,
-  [KIND.PARK]: () => command(OFFER_BACKLOG),
-  // The child was released; `backlog:drive` holds the next launch until the limit resets.
-  [KIND.USAGE_LIMIT]: () => command(OFFER_BACKLOG),
-  [KIND.CUT]: (issue_number) => command(`pnpm josh run:cut --resume ${issue_number}`),
-  // A stall is undispatched ready work with a free lane, so its next step is exactly a park's: offer
-  // the backlog. The detector only reports the stall; reading it here as a dispatch is what turns the
-  // report into the action that resolves it.
-  [KIND.STALL]: () => command(OFFER_BACKLOG),
-  // The post-implementation region is with a detached ship supervisor: nothing
-  // is the agent's until the supervisor stops or the issue closes, which the terminal read answers.
-  [KIND.SHIP_LAUNCH]: () => verdict(WAIT),
-  // The supervisor stopped at a failed stage and handed control back — the next step is reading the
-  // report it stopped on, which names the stage and why.
-  [KIND.SHIP_STOP]: (issue_number) => command(`pnpm josh ship --log ${issue_number}`)
-};
-var PARENT_ONLY_EVENTS = /* @__PURE__ */ new Set([KIND.MERGE, KIND.OUTAGE, KIND.USAGE_LIMIT]);
-function stop_action(input) {
-  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP);
-}
-function drain_action(input) {
-  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT);
-}
-var HAND_OFF_COMMAND = "pnpm josh run:carry --cut";
-function can_hand_off(input) {
-  if (input.is_lane_child || input.is_at_cut_cap) return false;
-  return input.carry_kind === "carried" && !input.has_completion_callback;
-}
-function child_launch_action(input) {
-  return can_hand_off(input) ? command(HAND_OFF_COMMAND) : verdict(WAIT);
-}
-var FULL_INPUT_ACTIONS = {
-  [KIND.STOP]: stop_action,
-  [KIND.DRAIN]: drain_action,
-  [KIND.CHILD_LAUNCH]: child_launch_action,
-  // A person's restart re-dispatched the child, so the parent's position is a launch's.
-  [KIND.RESTART]: child_launch_action
-};
-function event_action(event, issue_number, is_lane_child) {
-  if (is_lane_child && PARENT_ONLY_EVENTS.has(event)) return verdict(STOP);
-  return EVENT_ACTIONS[event]?.(issue_number) ?? verdict(UNKNOWN);
-}
-var IMPLEMENTATION_POSITIONS = /* @__PURE__ */ new Set([KIND.PLAN, KIND.RESUME]);
-function is_pre_implementation(last_event) {
-  return last_event === void 0 || IMPLEMENTATION_POSITIONS.has(last_event);
-}
-function pre_implementation_action(input) {
-  return verdict(pre_verdict(input));
-}
-function owes_merge(input) {
-  return input.is_merge_owed && input.carry_kind === "carried" && !input.is_lane_child;
-}
-function closed_action(input) {
-  if (owes_merge(input)) return merge_command(input.issue_number);
-  if (closed_verdict(input) === ALREADY_DONE) return verdict(ALREADY_DONE);
-  const message = git_stash.work_message(input.issue_number, ALREADY_DONE);
-  return {
-    kind: "decide",
-    line: `decide: ${session_cite.issue(input.issue_number)} is closed but this tree holds uncommitted work \u2014 keep it with \`pnpm josh stash:push "${message}"\` | carry it into a new issue`
-  };
-}
-function is_handed_off_parent(input) {
-  return input.is_handed_off && input.carry_kind === "carried" && !input.is_lane_child;
-}
-function carry_terminal_action(input) {
-  if (input.carry_kind === "unreadable") return verdict(UNKNOWN);
-  if (is_handed_off_parent(input)) return verdict(STOP);
-  return void 0;
-}
-function terminal_action(input) {
-  const carry_action = carry_terminal_action(input);
-  if (carry_action !== void 0) return carry_action;
-  if (input.state === void 0) return verdict(UNKNOWN);
-  if (input.state === CLOSED) return closed_action(input);
-  return void 0;
-}
-var RETROSPECTIVE_POSITIONS = /* @__PURE__ */ new Set([KIND.DRAIN, KIND.STOP]);
-function is_retrospective_position(input) {
-  return RETROSPECTIVE_POSITIONS.has(input.last_event ?? "") && run_retrospective.is_owed(input);
-}
-function driving_action(input) {
-  if (is_retrospective_position(input)) return command(RETROSPECTIVE_COMMAND);
-  return input.is_at_cut_cap ? verdict(WAIT) : command(HAND_OFF_COMMAND);
-}
-function parent_action(input) {
-  if (input.is_lane_child) return verdict(UNKNOWN);
-  const terminal = carry_terminal_action(input);
-  if (terminal !== void 0) return terminal;
-  return input.is_driving ? driving_action(input) : verdict(UNKNOWN);
-}
-function next_action(input) {
-  const terminal = terminal_action(input);
-  if (terminal !== void 0) return terminal;
-  if (is_pre_implementation(input.last_event)) return pre_implementation_action(input);
-  const event = input.last_event ?? "";
-  const full_input_action = FULL_INPUT_ACTIONS[event];
-  if (full_input_action !== void 0) return full_input_action(input);
-  return event_action(event, input.issue_number, input.is_lane_child);
-}
-var run_step = {
-  ALREADY_DONE,
-  HAND_OFF_COMMAND,
-  HUMAN_REVIEW,
-  IMPLEMENT,
-  KEEP_WORK,
-  RETROSPECTIVE_COMMAND,
-  STOP,
-  UNKNOWN,
-  UPDATE_DEPS,
-  VOCABULARY,
-  WAIT,
-  next_action,
-  parent_action,
-  pre_verdict
-};
-
-export {
-  run_step
-};

package/dist/commands/chunk-YNPRJCEO.js

@@ -1,81 +0,0 @@
-import {
-  lane_close
-} from "./chunk-ZZFFSQF4.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  repository_lock
-} from "./chunk-P4KIQRSL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/lane/lane-preserve.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-function preserved_comment(message, cause) {
-  return [
-    `The lane held uncommitted work when ${cause}, so it was stashed:`,
-    `- recover with \`pnpm josh stash:pop "${message}"\``
-  ].join("\n");
-}
-async function push_work(issue, directory, occasion) {
-  const message = git_stash.work_message(issue, occasion);
-  await git_stash.push(message, directory);
-  return message;
-}
-async function announce(issue, message, cause) {
-  await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause));
-}
-var KEEP_LOCK_PREFIX = "josh-lane-keep-lock-";
-var KEEP_LOCK_WAIT_MS = 6e4;
-var KEEP_LOCK_TIMEOUT = "another keep of this lane held the lock for the whole wait";
-function keep_lock_path(issue, directory) {
-  return repository_lock.lock_path(`${KEEP_LOCK_PREFIX}${issue}-`, directory);
-}
-async function stash_of(issue, directory, occasion) {
-  if (!await git_stash.has_work(directory)) return void 0;
-  return await push_work(issue, directory, occasion);
-}
-async function locked_stash_of(issue, directory, occasion) {
-  const kept = await repository_lock.with_lock(
-    async () => ({ stash: await stash_of(issue, directory, occasion) }),
-    keep_lock_path(issue, directory),
-    KEEP_LOCK_WAIT_MS
-  );
-  if (kept === void 0) return { kind: "unsaved", directory, reason: KEEP_LOCK_TIMEOUT };
-  return { kind: "saved", stash: kept.stash };
-}
-async function keep_work(issue, directory, occasion) {
-  try {
-    return await locked_stash_of(issue, directory, occasion);
-  } catch (error) {
-    return { kind: "unsaved", directory, reason: error_text.message_of(error) };
-  }
-}
-async function preserve_lane(issue, occasion, cause) {
-  const lane = await lane_close.resolve_lane(issue);
-  const { directory } = lane.targets;
-  if (!existsSync(path.join(directory, ".git"))) return true;
-  const kept = await keep_work(issue, directory, occasion);
-  if (kept.kind === "unsaved") {
-    console.error(
-      `${session_cite.issue(issue)}: uncommitted work could not be stashed \u2014 lane left at ${directory}`
-    );
-    return false;
-  }
-  if (kept.stash !== void 0) await announce(issue, kept.stash, cause);
-  return true;
-}
-var lane_preserve = { announce, keep_work, preserve_lane };
-
-export {
-  lane_preserve
-};

package/dist/commands/chunk-YTBQAD5W.js

@@ -1,170 +0,0 @@
-import {
-  epic_issue
-} from "./chunk-IAD4WLLI.js";
-import {
-  issue_priority
-} from "./chunk-XI2ABCRX.js";
-import {
-  issue_run_hold
-} from "./chunk-QX2R6UJG.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  ALREADY_DONE_LABEL,
-  AUTO_OK_LABEL,
-  EPIC_LABEL,
-  IN_PROGRESS_LABEL,
-  NEEDS_DECISION_LABEL,
-  NEEDS_HUMAN_REVIEW_LABEL,
-  PRIORITY_HIGH_LABEL,
-  RUN_LANE_LABEL,
-  RUN_STALLED_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  run_carry
-} from "./chunk-MPGJ4ONJ.js";
-
-// scripts/run/add/run-add-epic.ts
-function is_epic(labels) {
-  return has_label_name(labels, EPIC_LABEL);
-}
-function tracked_of(carry) {
-  return new Set(run_carry.remaining_of(carry));
-}
-function track(issue, tracked = /* @__PURE__ */ new Set()) {
-  return { kind: "tracked", issue, is_new: !tracked.has(issue) };
-}
-function describe(issue, is_new, is_priority) {
-  if (!is_new) return `tracking ${issue} \xB7 already a root of this run`;
-  return `tracking ${issue} \xB7 epic root, ${is_priority ? "ahead of the queue" : "end of the queue"}`;
-}
-function event_text(issue) {
-  return `added ${issue} \xB7 tracked as an epic root`;
-}
-var run_add_epic = { describe, event_text, is_epic, track, tracked_of };
-
-// scripts/run/add/run-add.ts
-var DEFAULT_CONTEXT = { is_retry: false, done: [], active: /* @__PURE__ */ new Set() };
-var PROTECTED_LABELS = [NEEDS_DECISION_LABEL, NEEDS_HUMAN_REVIEW_LABEL, ALREADY_DONE_LABEL];
-var ISSUE_PREFIX = "#";
-var BLOCKER_SEPARATOR = ", ";
-function labels_for(is_priority, existing = []) {
-  const opted_in = [AUTO_OK_LABEL, RUN_LANE_LABEL];
-  return is_priority && !issue_priority.is_typed(existing) ? [...opted_in, PRIORITY_HIGH_LABEL] : opted_in;
-}
-async function first_unapplied(issue, labels, ports) {
-  const [label, ...rest] = labels;
-  if (label === void 0) return void 0;
-  if (!await ports.apply_label(issue, label)) return label;
-  return await first_unapplied(issue, rest, ports);
-}
-function retry_required(issue, labels, context) {
-  return !context.is_retry && (context.done.includes(issue) || has_label_name(labels, RUN_STALLED_LABEL));
-}
-function terminal_refusal(issue, context) {
-  return context.settled?.has(issue) ? "not a mechanical stop" : void 0;
-}
-function protected_label(labels) {
-  return PROTECTED_LABELS.find((label) => has_label_name(labels, label));
-}
-function label_refusal(labels) {
-  return protected_label(labels) ?? (issue_run_hold.is_held(labels) ? IN_PROGRESS_LABEL : void 0);
-}
-function refusal(issue, view, context) {
-  const labels = view.labels ?? [];
-  const label = label_refusal(labels);
-  if (label !== void 0) return label;
-  if (context.active.has(String(issue))) return "active lane";
-  if (retry_required(issue, labels, context)) return "use --retry";
-  return terminal_refusal(issue, context);
-}
-async function label_one(issue, labels, ports, context) {
-  const label = await first_unapplied(issue, labels, ports);
-  if (label !== void 0) return { kind: "unlabeled", issue, label };
-  if (context.is_retry && !await ports.clear_label(issue, RUN_STALLED_LABEL)) {
-    return { kind: "refused", issue, reason: "could not clear run:stalled" };
-  }
-  return { kind: "queued", issue, blockers: [] };
-}
-function decided(issue, view, context) {
-  const reason = refusal(issue, view, context);
-  if (reason !== void 0) return { kind: "refused", issue, reason };
-  return run_add_epic.is_epic(view.labels ?? []) ? run_add_epic.track(issue, context.tracked) : void 0;
-}
-async function add_one(issue, is_priority, ports, context) {
-  const view = await ports.read_issue(issue);
-  if (view === void 0) return { kind: "unreadable", issue };
-  if (!view.is_open) return { kind: "closed", issue };
-  const settled = decided(issue, view, context);
-  if (settled !== void 0) return settled;
-  const outcome = await label_one(issue, labels_for(is_priority, view.labels), ports, context);
-  return outcome.kind === "queued" ? { ...outcome, blockers: view.blockers } : outcome;
-}
-async function add_all(issues, is_priority, ports, context = DEFAULT_CONTEXT) {
-  const [issue, ...rest] = issues;
-  if (issue === void 0) return [];
-  const outcome = await add_one(issue, is_priority, ports, context);
-  return [outcome, ...await add_all(rest, is_priority, ports, context)];
-}
-function is_added(outcome) {
-  return outcome.kind === "queued" || outcome.kind === "tracked" && outcome.is_new;
-}
-function additions_of(outcomes, is_priority) {
-  return outcomes.filter((outcome) => is_added(outcome)).map((outcome) => ({ issue: outcome.issue, is_priority }));
-}
-function roots_of(outcomes) {
-  return new Set(
-    outcomes.filter((outcome) => outcome.kind === "tracked" && outcome.is_new).map((outcome) => outcome.issue)
-  );
-}
-function blockers_text(blockers) {
-  return blockers.map((blocker) => `${ISSUE_PREFIX}${String(blocker)}`).join(BLOCKER_SEPARATOR);
-}
-function queued_line(issue, blockers, is_priority) {
-  if (blockers.length > 0) return `queued ${issue} \xB7 waiting: blocked by ${blockers_text(blockers)}`;
-  return `queued ${issue} \xB7 ${is_priority ? "next free lane" : "end of the queue"}`;
-}
-function refused_reason(outcome) {
-  if (outcome.kind === "closed") return "closed";
-  if (outcome.kind === "unreadable") return "could not be read";
-  if (outcome.kind === "refused") return outcome.reason;
-  return `could not apply \`${outcome.label}\``;
-}
-function describe2(outcome, is_priority) {
-  const issue = `${ISSUE_PREFIX}${String(outcome.issue)}`;
-  if (outcome.kind === "queued") return queued_line(issue, outcome.blockers, is_priority);
-  if (outcome.kind === "tracked") return run_add_epic.describe(issue, outcome.is_new, is_priority);
-  return `refused ${issue} \xB7 ${refused_reason(outcome)}`;
-}
-function is_all_added(outcomes) {
-  return outcomes.every((outcome) => outcome.kind === "queued" || outcome.kind === "tracked");
-}
-var run_add = {
-  add_all,
-  additions_of,
-  describe: describe2,
-  is_all_added,
-  labels_for,
-  protected_label,
-  roots_of
-};
-
-// scripts/run/add/run-add-issue.ts
-async function read(issue) {
-  const result = await git_gh_command.issue_get_state_and_relations_classified(String(issue));
-  if (result.kind !== "read") return void 0;
-  const parsed = epic_issue.parse_epic_issue(result.json);
-  if (parsed === void 0) return void 0;
-  const relation = parsed.blockedBy;
-  if (relation === void 0) return void 0;
-  return relation.totalCount === relation.nodes.length ? parsed : void 0;
-}
-var run_add_issue = { read };
-
-export {
-  run_add_epic,
-  run_add,
-  run_add_issue
-};

package/dist/commands/chunk-YVH2OLDS.js

@@ -1,104 +0,0 @@
-import {
-  git_worktree
-} from "./chunk-W3FX7FYN.js";
-import {
-  IGNORED_CACHE_FILES
-} from "./chunk-TBIX5FRN.js";
-import {
-  ENV_FILE_NAME
-} from "./chunk-IGD6QJPH.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/git/git-remote-branch.ts
-async function ask(branch_name) {
-  try {
-    const heads = await git_worktree.ls_remote_branch(branch_name);
-    return heads.trim() === "" ? "absent" : "present";
-  } catch {
-    return "unreachable";
-  }
-}
-var git_remote_branch = {
-  ask
-};
-
-// scripts/lane/lane-leftover.ts
-import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, rmSync } from "node:fs";
-import path from "node:path";
-var REGENERATED_PATHS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  ENV_FILE_NAME,
-  ...IGNORED_CACHE_FILES
-]);
-var GIT_POINTER = ".git";
-var GITDIR_PREFIX = "gitdir: ";
-var NAMED_PATH_LIMIT = 10;
-function parse_objects(listing) {
-  return new Set(listing.split("\n").map((line) => line.split(" ", 1)[0] ?? ""));
-}
-async function recoverable_objects() {
-  return parse_objects(await git_spawn.read(["rev-list", "--objects", "--all"]));
-}
-function blob_id(file) {
-  const content = lstatSync(file).isSymbolicLink() ? Buffer.from(readlinkSync(file)) : readFileSync(file);
-  return createHash("sha1").update(`blob ${String(content.length)}\0`).update(content).digest("hex");
-}
-function walk_files(directory, relative) {
-  return readdirSync(path.join(directory, relative), { withFileTypes: true }).flatMap((entry) => {
-    const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
-    return entry.isDirectory() ? walk_files(directory, child) : child;
-  });
-}
-function list_files(directory) {
-  return readdirSync(directory).filter((name) => !REGENERATED_PATHS.has(name)).flatMap(
-    (name) => lstatSync(path.join(directory, name)).isDirectory() ? walk_files(directory, name) : name
-  );
-}
-function is_dangling_pointer(directory) {
-  const file = path.join(directory, GIT_POINTER);
-  if (!lstatSync(file).isFile()) return false;
-  const pointer = readFileSync(file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX)) return false;
-  return !existsSync(path.resolve(directory, pointer.slice(GITDIR_PREFIX.length)));
-}
-function is_reclaimable_file(directory, relative, recoverable) {
-  if (relative === GIT_POINTER) return is_dangling_pointer(directory);
-  return recoverable.has(blob_id(path.join(directory, relative)));
-}
-function foreign_paths(directory, recoverable) {
-  const pointer = lstatSync(path.join(directory, GIT_POINTER), { throwIfNoEntry: false });
-  if (pointer?.isDirectory() === true) return [GIT_POINTER];
-  return list_files(directory).filter(
-    (relative) => !is_reclaimable_file(directory, relative, recoverable)
-  );
-}
-function refusal(directory, foreign) {
-  const named = foreign.slice(0, NAMED_PATH_LIMIT).join(", ");
-  const rest = foreign.length - NAMED_PATH_LIMIT;
-  const more = rest > 0 ? ` and ${String(rest)} more` : "";
-  return new Error(
-    `${directory} already exists but git does not register it as a work tree, and it holds files the repository does not: ${named}${more}. It was left in place so nothing is lost \u2014 move those files out, delete the directory, and open the lane again.`
-  );
-}
-async function reclaim(directory) {
-  if (!existsSync(directory)) return;
-  const foreign = foreign_paths(directory, await recoverable_objects());
-  if (foreign.length > 0) throw refusal(directory, foreign);
-  rmSync(directory, { force: true, recursive: true });
-}
-var lane_leftover = {
-  blob_id,
-  foreign_paths,
-  parse_objects,
-  reclaim,
-  recoverable_objects
-};
-
-export {
-  git_remote_branch,
-  lane_leftover
-};