@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-23TWJOAI.js

@@ -0,0 +1,172 @@
+import {
+  doctor_consumer
+} from "./chunk-S4OZJIXD.js";
+import {
+  own_formatter,
+  project_profile
+} from "./chunk-EJG5ZJKD.js";
+import {
+  NOT_USED_MARKER,
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  find_local_bin_upwards
+} from "./chunk-SVV4U5AR.js";
+import {
+  ancestor_directories,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gate/project-checks.ts
+import { existsSync, globSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "target",
+  "dist",
+  "build",
+  ".svelte-kit"
+]);
+var WEB_EXTENSIONS = ["html", "css", "js", "jsx", "mjs", "cjs"];
+var WEB_FILES = `**/*.{${WEB_EXTENSIONS.join(",")}}`;
+var DEFAULT_FORMAT_SCOPE = "auto";
+var SCRIPT_FILES = "**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+var TYPE_FILES = "**/*.{ts,tsx,mts,cts}";
+var ESLINT_CONFIGS = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+var CSPELL_CONFIGS = [
+  "cspell.config.yaml",
+  "cspell.config.yml",
+  "cspell.config.json",
+  "cspell.config.js",
+  "cspell.config.cjs",
+  "cspell.config.mjs",
+  "cspell.json",
+  "cspell.yaml"
+];
+var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
+var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
+var object_schema = z.record(z.string(), z.unknown());
+function project_root(directory) {
+  return ancestor_directories.nearest(
+    directory,
+    (candidate) => existsSync(package_manifest.manifest_path(candidate))
+  ) ?? directory;
+}
+function is_kit_repository(directory) {
+  return !doctor_consumer.is_kit_consumer(project_root(directory));
+}
+function is_ignored(entry) {
+  return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part));
+}
+function has_files(directory, pattern) {
+  return globSync(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
+}
+function has_config(directory, names) {
+  return names.some((name) => existsSync(path.join(project_root(directory), name)));
+}
+function has_bin(directory, bin_name) {
+  return find_local_bin_upwards(directory, bin_name) !== void 0;
+}
+function josh_settings(manifest) {
+  return json_value.is_record(manifest) ? manifest["josh"] : void 0;
+}
+function is_basic_manifest(manifest) {
+  const josh = josh_settings(manifest);
+  if (!json_value.is_record(josh)) return false;
+  return project_profile.parse_profile(josh["profile"]) === "basic";
+}
+function read_manifest(directory) {
+  return package_manifest.read_manifest_if_valid(project_root(directory), z.unknown());
+}
+function is_basic(directory) {
+  return is_basic_manifest(read_manifest(directory));
+}
+function is_declared(directory, package_name) {
+  const manifest = object_schema.safeParse(read_manifest(directory));
+  if (!manifest.success) return false;
+  return DEPENDENCY_FIELDS.some((field) => {
+    const dependencies = object_schema.safeParse(manifest.data[field]);
+    return dependencies.success && Object.hasOwn(dependencies.data, package_name);
+  });
+}
+function missing_tool_reason(directory, package_name, bin_name) {
+  if (has_bin(directory, bin_name) || is_declared(directory, package_name)) return void 0;
+  return `${package_name} is not installed`;
+}
+function skip_notice(check, reason) {
+  return `josh ${check}: ${reason} ${SKIP_MARKER} ${check}, ${NOT_USED_MARKER}.`;
+}
+function ran_notice(check) {
+  return `josh ${check}: ran and reported no problems.`;
+}
+function type_check_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  if (!has_files(directory, TYPE_FILES)) return "no TypeScript files were found";
+  if (!has_config(directory, TYPE_CONFIGS)) return "no TypeScript configuration was found";
+  return missing_tool_reason(directory, "typescript", "tsc");
+}
+function prettier_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  const formatter = own_formatter.find_config(project_root(directory));
+  if (formatter !== void 0) return `${formatter} configures the project's own formatter`;
+  if (!has_files(directory, WEB_FILES)) return "no HTML, CSS or JavaScript files were found";
+  return missing_tool_reason(directory, "prettier", "prettier");
+}
+function format_scope(directory) {
+  const manifest = package_manifest.read_manifest_if_valid(
+    project_root(directory),
+    package_manifest.josh_schemas.format
+  );
+  return manifest?.josh?.format ?? DEFAULT_FORMAT_SCOPE;
+}
+function is_web_file(file_path) {
+  return WEB_EXTENSIONS.includes(path.extname(file_path).slice(1));
+}
+function prettier_targets(directory, targets) {
+  if (!is_basic(directory) || format_scope(directory) === "all") return targets;
+  const web_targets = targets.filter((target) => is_web_file(target));
+  return web_targets.length > 0 ? web_targets : [WEB_FILES];
+}
+function eslint_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  if (!has_files(directory, SCRIPT_FILES)) return "no JavaScript or TypeScript files were found";
+  if (!has_config(directory, ESLINT_CONFIGS)) return "no ESLint configuration was found";
+  return missing_tool_reason(directory, "eslint", "eslint");
+}
+var project_checks = {
+  CSPELL_CONFIGS,
+  ESLINT_CONFIGS,
+  TYPE_FILES,
+  WEB_FILES,
+  eslint_skip_reason,
+  has_bin,
+  has_config,
+  has_files,
+  is_basic,
+  is_kit_repository,
+  prettier_skip_reason,
+  prettier_targets,
+  project_root,
+  ran_notice,
+  read_manifest,
+  skip_notice,
+  type_check_skip_reason
+};
+
+export {
+  project_checks
+};

package/dist/commands/chunk-24MXEDSJ.js

@@ -0,0 +1,81 @@
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  RUN_LANE_LABEL,
+  RUN_SOLO_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/backlog/backlog-triage-decision.ts
+var OPTIONS = {
+  defect: { type: "string" },
+  verification: { type: "string" },
+  "every-run": { type: "string" }
+};
+var ANSWERS = /* @__PURE__ */ new Set(["yes", "no", "unknown"]);
+var USAGE = "Usage: josh backlog:triage --decide --defect yes|no|unknown --verification yes|no|unknown --every-run yes|no|unknown";
+function decide(answers) {
+  if (answers.includes("no")) return RUN_LANE_LABEL;
+  if (answers.includes("unknown")) return "judge";
+  return RUN_SOLO_LABEL;
+}
+function is_answer(answer) {
+  return answer !== void 0 && ANSWERS.has(answer);
+}
+function answers_of(argv) {
+  const values = cli_flags.values_of(argv, OPTIONS);
+  const answers = [values?.defect, values?.verification, values?.["every-run"]];
+  return answers.every(is_answer) ? answers : void 0;
+}
+function run(argv) {
+  const answers = answers_of(argv);
+  if (answers === void 0) {
+    console.error(USAGE);
+    return 1;
+  }
+  console.info(decide(answers));
+  return 0;
+}
+var backlog_triage_decision = { OPTIONS, decide, is_answer, run };
+
+// scripts/issue/issue-run-verdict.ts
+var RUN_LABEL_OPTIONS = {
+  ...backlog_triage_decision.OPTIONS,
+  lane: { type: "boolean" },
+  solo: { type: "boolean" }
+};
+function solo_label_of(flags) {
+  const answers = [flags.defect, flags.verification, flags["every-run"]];
+  const verdict = answers.every((answer) => backlog_triage_decision.is_answer(answer)) ? backlog_triage_decision.decide(answers) : "judge";
+  if (verdict === RUN_SOLO_LABEL) return verdict;
+  console.error(
+    `--solo refused: ${verdict}; answer --defect, --verification and --every-run with yes`
+  );
+  return void 0;
+}
+function run_label_of(flags) {
+  if (flags.lane === flags.solo) return void 0;
+  return flags.lane === true ? RUN_LANE_LABEL : solo_label_of(flags);
+}
+async function apply_labels(issue, labels) {
+  for (const label of labels) {
+    const write = await git_gh_command.issue_apply_label(issue, label);
+    if (!write.is_applied) return `could not apply \`${label}\`: ${write.reason}`;
+  }
+  return void 0;
+}
+function comment_with_answers(body, flags) {
+  if (flags.solo !== true) return body;
+  return `${body}
+
+solo-run answers: defect ${String(flags.defect)} \xB7 verification ${String(flags.verification)} \xB7 every-run ${String(flags["every-run"])}`;
+}
+var issue_run_verdict = { RUN_LABEL_OPTIONS, run_label_of, apply_labels, comment_with_answers };
+
+export {
+  backlog_triage_decision,
+  issue_run_verdict
+};

package/dist/commands/chunk-25LVQDOF.js

@@ -0,0 +1,183 @@
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  cost_blocks,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  git_argv
+} from "./chunk-ZEVI2ZGI.js";
+
+// scripts/rules/interpreter-options.ts
+var INLINE_FLAGS = /* @__PURE__ */ new Map([
+  ["node", /* @__PURE__ */ new Set(["-e", "-p", "--eval", "--print"])],
+  ["python", /* @__PURE__ */ new Set(["-c"])],
+  ["python3", /* @__PURE__ */ new Set(["-c"])],
+  ["perl", /* @__PURE__ */ new Set(["-e", "-E"])],
+  ["ruby", /* @__PURE__ */ new Set(["-e"])],
+  ["bun", /* @__PURE__ */ new Set(["-e", "--eval", "--print"])],
+  ["deno", /* @__PURE__ */ new Set(["eval"])]
+]);
+var SHELL_SCRIPT_LETTERS = "c";
+var SHELLS = /* @__PURE__ */ new Set(["bash", "eval", "sh", "zsh"]);
+var FLAG_PREFIX = "-";
+var LONG_FLAG = "--";
+var QUOTING = /["'\\]/gu;
+var SHORT_FLAG = /^-[^-]/u;
+var WHITESPACE = /\s/u;
+var NEXT = 1;
+var AFTER_VALUE = 2;
+var NODE_VALUES = "-r --require --import --loader --experimental-loader -C --conditions --inspect-port --debug-port --input-type --env-file --env-file-if-exists --title --allow-fs-read --allow-fs-write --bench-isolation --bench-name-pattern --bench-reporter --bench-reporter-destination --bench-samples --bench-warmup --build-sea --build-snapshot-config --experimental-config-file --config-file --cpu-prof-dir --cpu-prof-interval --cpu-prof-name --diagnostic-dir --disable-proto --disable-warning --dns-result-order --experimental-package-map --experimental-sea-config --experimental-test-tag-filter --heap-prof-dir --heap-prof-interval --heap-prof-name --heapsnapshot-near-heap-limit --heapsnapshot-signal --icu-data-dir --inspect-publish-uid --localstorage-file --max-http-header-size --max-old-space-size-percentage --network-family-autoselection-attempt-timeout --openssl-config --process-timeout --redirect-warnings --report-directory --report-dir --report-filename --report-signal --run --secure-heap --secure-heap-min --snapshot-blob --test-concurrency --test-coverage-branches --test-coverage-exclude --test-coverage-functions --test-coverage-include --test-coverage-lines --test-global-setup --experimental-test-isolation --test-isolation --test-name-pattern --test-random-seed --test-reporter --test-reporter-destination --test-rerun-failures --test-shard --test-skip-pattern --test-timeout --tls-cipher-list --tls-keylog --trace-event-categories --trace-event-file-pattern --trace-require-module --unhandled-rejections --use-largepages --v8-pool-size --vfs-load --watch-kill-signal --watch-path";
+var INTERPRETER_VALUES = /* @__PURE__ */ new Map([
+  ["node", new Set(NODE_VALUES.split(" "))],
+  ["python", /* @__PURE__ */ new Set(["-W", "-X"])],
+  ["python3", /* @__PURE__ */ new Set(["-W", "-X"])],
+  ["perl", /* @__PURE__ */ new Set(["-I", "-M", "-m", "-F"])],
+  ["ruby", /* @__PURE__ */ new Set(["-I", "-r", "-C", "-E", "-F", "-K"])],
+  ["bun", /* @__PURE__ */ new Set(["-r", "--require", "--preload", "--cwd", "--config"])],
+  [
+    "deno",
+    /* @__PURE__ */ new Set([
+      "-c",
+      "--config",
+      "--import-map",
+      "--lock",
+      "--cert",
+      "--location",
+      "--v8-flags",
+      "--seed",
+      "--log-level"
+    ])
+  ]
+]);
+var SHELL_VALUES = /* @__PURE__ */ new Set([
+  "-o",
+  "+o",
+  "-O",
+  "+O",
+  "--rcfile",
+  "--init-file"
+]);
+function syntax_word(word) {
+  return WHITESPACE.test(word) ? word : word.replaceAll(QUOTING, "");
+}
+function matches_short_flag(word, flag) {
+  return SHORT_FLAG.test(word) && word.slice(1).includes(flag.slice(1));
+}
+function matches_inline_flag(word, flags) {
+  return [...flags].some((flag) => {
+    if (word === flag) return true;
+    if (!flag.startsWith(FLAG_PREFIX)) return false;
+    if (flag.startsWith(LONG_FLAG)) return word.startsWith(`${flag}=`);
+    return matches_short_flag(word, flag);
+  });
+}
+function value_index(word, values) {
+  for (let index = NEXT; index < word.length; index += NEXT) {
+    if (values?.has(`-${word.charAt(index)}`)) return index;
+  }
+  return -1;
+}
+function option_prefix(word, values) {
+  if (!SHORT_FLAG.test(word)) return word;
+  const index = value_index(word, values);
+  return index === -1 ? word : word.slice(0, index);
+}
+function option_width(word, prefix, values) {
+  if (values?.has(word)) return AFTER_VALUE;
+  if (prefix !== word && word.length === prefix.length + NEXT) return AFTER_VALUE;
+  return NEXT;
+}
+function value_flags(name) {
+  return SHELLS.has(name) ? SHELL_VALUES : INTERPRETER_VALUES.get(name);
+}
+function is_script_operand(word, values) {
+  return !word.startsWith(FLAG_PREFIX) && !values?.has(word);
+}
+function option_step(word, flags, name) {
+  if (word === LONG_FLAG) return 0;
+  const values = value_flags(name);
+  const prefix = option_prefix(word, values);
+  if (matches_inline_flag(prefix, flags)) return -1;
+  if (is_script_operand(word, values)) return 0;
+  return option_width(word, prefix, values);
+}
+function interpreter_word(word, name) {
+  return SHELLS.has(name) ? word.replace(/^\+/u, "-") : word;
+}
+function found_index(step, index) {
+  return step === -1 ? index : -1;
+}
+function inline_index(call, flags) {
+  let index = 0;
+  while (index < call.args.length) {
+    const word = interpreter_word(syntax_word(call.args[index] ?? ""), call.name);
+    const step = option_step(word, flags, call.name);
+    if (step <= 0) return found_index(step, index);
+    index += step;
+  }
+  return -1;
+}
+function is_inline_execution(call) {
+  if (call.name === "eval") return true;
+  const is_shell = SHELLS.has(call.name);
+  const flags = is_shell ? /* @__PURE__ */ new Set([`-${SHELL_SCRIPT_LETTERS}`]) : INLINE_FLAGS.get(call.name);
+  return flags !== void 0 && inline_index(call, flags) !== -1;
+}
+function shell_script_index(call) {
+  return inline_index(call, /* @__PURE__ */ new Set([`-${SHELL_SCRIPT_LETTERS}`]));
+}
+var interpreter_options = { SHELLS, is_inline_execution, shell_script_index, syntax_word };
+
+// scripts/rules/bash-triggers.ts
+function on_bash_command(is_match) {
+  return function is_trigger(call, ...rest) {
+    if (call.name !== cost_blocks.BASH_TOOL) return false;
+    return is_match(time_shell.bash_command(call.input), ...rest);
+  };
+}
+var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
+var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
+var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
+var GH_API_COMMAND = /\bgh\s+api\b/u;
+var SHELL_SCRIPT_RUNNER = /\b(?:(?:ba|z|da|k)?sh\s+(?:-\w+\s+)*-\w*c\b|eval\b)/u;
+function spoken_line(command) {
+  if (time_shell.has_heredoc(command)) return command;
+  const plain = time_shell.unquoted(command);
+  return SHELL_SCRIPT_RUNNER.test(plain) ? command : plain;
+}
+var LEADING_SHELL_SCRIPT_RUNNER = new RegExp(`^${SHELL_SCRIPT_RUNNER.source}`, "u");
+function shell_script_of(segment) {
+  const call = git_argv.program_of(segment);
+  if (call === void 0) return void 0;
+  const spoken = [call.name, ...call.args].join(" ");
+  if (!LEADING_SHELL_SCRIPT_RUNNER.test(spoken)) return void 0;
+  const index = interpreter_options.shell_script_index(call);
+  const script = call.name === "eval" ? call.args.join(" ") : call.args[index + 1] ?? "";
+  return script.replace(/^(["'])([\s\S]*)\1$/u, "$2");
+}
+function is_direct_filing(command) {
+  const spoken = spoken_line(command);
+  if (ISSUE_CREATE_COMMAND.test(spoken)) return true;
+  return GH_API_COMMAND.test(spoken) && ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
+}
+var FILING_NAMES = /* @__PURE__ */ new Set(["issue:file"]);
+function is_issue_filing_segment(segment) {
+  return shell_segments.is_josh_command(segment, FILING_NAMES);
+}
+function is_issue_filing(command) {
+  return shell_segments.segments_of(command).some((segment) => is_issue_filing_segment(segment));
+}
+var bash_triggers = {
+  is_direct_filing,
+  is_issue_filing,
+  is_issue_filing_segment,
+  on_bash_command,
+  shell_script_of
+};
+
+export {
+  interpreter_options,
+  bash_triggers
+};

package/dist/commands/chunk-25LYH5QR.js

@@ -0,0 +1,85 @@
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/hooks/check-commit-message.ts
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var PARENT_SEGMENT = "..";
+var COMMIT_MESSAGE_FILE_NAME = "COMMIT_EDITMSG";
+var FALLBACK_GIT_DIRECTORY = ".git";
+function is_inside(directory, resolved_path) {
+  const relative = path.relative(directory, resolved_path);
+  return relative !== "" && !relative.startsWith(PARENT_SEGMENT) && !path.isAbsolute(relative);
+}
+function is_safe_commit_message_path(file_path, git_directories) {
+  const resolved = path.resolve(file_path);
+  return git_directories.some((directory) => is_inside(directory, resolved)) || is_inside(os.tmpdir(), resolved);
+}
+function default_commit_message_path(git_directories) {
+  return path.join(git_directories[0] ?? FALLBACK_GIT_DIRECTORY, COMMIT_MESSAGE_FILE_NAME);
+}
+async function get_commit_message() {
+  const FILE_INDEX = 2;
+  const commit_message_file = process.argv.at(FILE_INDEX);
+  const git_directories = await git_command.git_directories();
+  const message_path = commit_message_file ?? default_commit_message_path(git_directories);
+  if (commit_message_file !== void 0 && !is_safe_commit_message_path(commit_message_file, git_directories)) {
+    throw new Error(
+      `Commit message file must be inside a git directory or the system temp dir: ${commit_message_file}`
+    );
+  }
+  try {
+    return readFileSync(message_path, "utf8").trim();
+  } catch (error) {
+    throw new Error(`Failed to read commit message file: ${message_path}`, { cause: error });
+  }
+}
+function extract_issue_number(branch_name) {
+  const branch_pattern = /^(\d+)-[\da-z-]+$/u;
+  const match = branch_pattern.exec(branch_name);
+  return match?.[1];
+}
+function create_error_message(issue_number, branch, message) {
+  const reference = issue_cite.plain_for("github", issue_number);
+  return `\u{1F6AB} Error: Commit message must include ${reference}
+   Current branch: ${branch}
+   Commit message: ${message}
+   Please include ${reference} in your commit message
+`;
+}
+async function check_commit_message() {
+  const current_branch = await git_command.branch();
+  const issue_number = extract_issue_number(current_branch);
+  if (issue_number === void 0) {
+    return {
+      success: true,
+      message: `\u2705 Branch format check passed: '${current_branch}' (no issue number required)`
+    };
+  }
+  const commit_message = await get_commit_message();
+  if (!commit_message.includes(issue_cite.plain_for("github", issue_number))) {
+    return {
+      success: false,
+      message: create_error_message(issue_number, current_branch, commit_message)
+    };
+  }
+  return {
+    success: true,
+    message: `\u2705 Commit message check passed: Found ${issue_cite.plain_for("github", issue_number)}`
+  };
+}
+async function run_check() {
+  const result = await check_commit_message();
+  console.info(result.message);
+  return result.success ? 0 : 1;
+}
+
+export {
+  extract_issue_number,
+  run_check
+};

package/dist/commands/chunk-2AH73ZTW.js

@@ -0,0 +1,84 @@
+import {
+  ls_remote_branch_arguments
+} from "./chunk-ZBFNQUY7.js";
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  PORCELAIN_FLAG
+} from "./chunk-B5GXZK3E.js";
+import {
+  INSTALL_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-worktree.ts
+var WORKTREE = "worktree";
+var ORIGIN = "origin";
+var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
+var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
+async function locked(arguments_, timeout_ms) {
+  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
+  const output = await repository_lock.with_lock(
+    async () => await git_spawn.read(arguments_, timeout_ms),
+    target,
+    WORKTREE_LOCK_MAX_WAIT_MS
+  );
+  if (output === void 0) {
+    throw new Error(
+      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
+    );
+  }
+  return output;
+}
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+}
+async function worktree_add(directory, branch_name, start_point) {
+  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
+  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
+}
+async function set_upstream(branch_name) {
+  await locked(["config", `branch.${branch_name}.remote`, ORIGIN]);
+  await locked(["config", `branch.${branch_name}.merge`, `refs/heads/${branch_name}`]);
+}
+async function worktree_add_detached(directory, commit) {
+  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
+}
+async function worktree_remove(directory) {
+  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
+}
+async function worktree_prune() {
+  return await locked([WORKTREE, "prune"]);
+}
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
+}
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
+}
+async function is_linked() {
+  const [own, common] = await git_command.git_directories();
+  return own !== common;
+}
+var git_worktree = {
+  is_linked,
+  branch_delete,
+  ls_remote_branch,
+  set_upstream,
+  worktree_add,
+  worktree_add_detached,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
+
+export {
+  git_worktree
+};

package/dist/commands/chunk-2BNLPPP4.js

@@ -0,0 +1,42 @@
+import {
+  has_stderr_field
+} from "./chunk-NAZ753DE.js";
+
+// scripts/gh/git-gh-helpers.ts
+function parse_pr_state_string(result) {
+  const trimmed = result.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function is_pr_already_exists_message(error_message) {
+  return error_message.toLowerCase().includes("already exists");
+}
+function get_error_message_with_stderr(error) {
+  if (!(error instanceof Error)) return String(error);
+  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
+${error.stderr}`;
+  return error.message;
+}
+function handle_pr_create_error(error) {
+  const error_message = get_error_message_with_stderr(error);
+  if (is_pr_already_exists_message(error_message)) {
+    throw new Error("PR_ALREADY_EXISTS");
+  }
+  throw error;
+}
+var git_gh_helpers = {
+  parse_pr_state_string,
+  get_error_message_with_stderr,
+  handle_pr_create_error
+};
+
+// scripts/gh/git-gh-rest-state.ts
+var MERGED_STATE = "MERGED";
+function to_gh_state(state) {
+  return state?.toUpperCase();
+}
+
+export {
+  git_gh_helpers,
+  MERGED_STATE,
+  to_gh_state
+};