@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-KKIMVXAP.js

@@ -1,280 +0,0 @@
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  find_local_bin_upwards
-} from "./chunk-SVV4U5AR.js";
-import {
-  PACKAGE_JSON
-} from "./chunk-WB4T3VY2.js";
-import {
-  LINT_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lines/line-budget.ts
-import { createHash } from "node:crypto";
-import { statSync } from "node:fs";
-import path2 from "node:path";
-import { execa } from "execa";
-import { z as z2 } from "zod";
-
-// scripts/lines/effective-limit.ts
-import { createRequire } from "node:module";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { z } from "zod";
-var ESLINT_MODULE = "eslint";
-var MAX_LINES_RULE = "max-lines";
-var SEVERITY_OFF = 0;
-var SEVERITY_OFF_NAME = "off";
-var CONFIG_FILE_OPTION = "overrideConfigFile";
-var module_schema = z.object({
-  ESLint: z.custom((value) => typeof value === "function")
-});
-var options_schema = z.looseObject({ max: z.number().int().positive() });
-var max_schema = z.number().int().positive();
-var severity_schema = z.union([z.number(), z.string()]);
-var entry_schema = z.tuple([severity_schema, z.union([max_schema, options_schema])]);
-var config_schema = z.object({ rules: z.record(z.string(), z.unknown()).optional() });
-var INTEGER_SKIPS = { skipBlankLines: false, skipComments: false };
-function is_off(severity) {
-  return severity === SEVERITY_OFF || severity === SEVERITY_OFF_NAME;
-}
-function normalized(option) {
-  return typeof option === "number" ? { max: option, ...INTEGER_SKIPS } : option;
-}
-function options_in(config) {
-  const rules = config_schema.safeParse(config).data?.rules ?? {};
-  const entry = entry_schema.safeParse(rules[MAX_LINES_RULE]);
-  if (!entry.success) return void 0;
-  const [severity, option] = entry.data;
-  return is_off(severity) ? void 0 : normalized(option);
-}
-async function resolver_for(project_root, config_file) {
-  try {
-    const require_from = createRequire(path.join(project_root, PACKAGE_JSON));
-    const loaded = await import(pathToFileURL(require_from.resolve(ESLINT_MODULE)).href);
-    const eslint_module = module_schema.parse(loaded);
-    return new eslint_module.ESLint({
-      cwd: project_root,
-      ...config_file !== void 0 && { [CONFIG_FILE_OPTION]: config_file }
-    });
-  } catch {
-    return void 0;
-  }
-}
-async function entry_for(resolver, file_path) {
-  try {
-    const options = options_in(await resolver.calculateConfigForFile(file_path));
-    return options === void 0 ? void 0 : [path.resolve(file_path), options];
-  } catch {
-    return void 0;
-  }
-}
-async function options_for(file_paths, project_root, config_file) {
-  const found = /* @__PURE__ */ new Map();
-  const resolver = file_paths.length === 0 ? void 0 : await resolver_for(project_root, config_file);
-  if (resolver === void 0) return found;
-  const entries = await Promise.all(
-    file_paths.map(async (file_path) => await entry_for(resolver, file_path))
-  );
-  const resolved = entries.filter((entry) => entry !== void 0);
-  for (const [file_path, options] of resolved) found.set(file_path, options);
-  return found;
-}
-var effective_limit = {
-  options_for,
-  options_in
-};
-
-// scripts/lines/line-budget.ts
-var MAX_LINES_RULE2 = "max-lines";
-var PROBE_MAX = 0;
-var PROBE_SEVERITY = "error";
-var NO_HEADROOM = 0;
-var NO_CODE_LINES = 0;
-var COUNT_PATTERN = /\((\d+)\)/u;
-var COUNT_GROUP = 1;
-var NEAR_LIMIT_FRACTION = 0.85;
-var PERCENT = 100;
-var ESLINT_BIN = "eslint";
-var PNPM = "pnpm";
-var PNPM_EXEC = "exec";
-var FORMAT_FLAGS = ["--format", "json", "--no-inline-config"];
-var RULE_FLAG = "--rule";
-var CACHE_PREFIX = "josh-lines-eslint-cache-";
-var CACHE_LOCATION_FLAG = "--cache-location";
-var CACHE_KEY_LENGTH = 8;
-var message_schema = z2.object({ ruleId: z2.string().nullish(), message: z2.string() });
-var result_schema = z2.object({ filePath: z2.string(), messages: z2.array(message_schema) });
-var results_schema = z2.array(result_schema);
-function near_limit_threshold(limit) {
-  return Math.ceil(limit * NEAR_LIMIT_FRACTION);
-}
-function near_limit_percent() {
-  return Math.round(NEAR_LIMIT_FRACTION * PERCENT);
-}
-function budget_of(code_lines, limit) {
-  return {
-    code_lines,
-    limit,
-    headroom: limit - code_lines,
-    is_near_limit: code_lines >= near_limit_threshold(limit)
-  };
-}
-function probe_rules(options) {
-  return { [MAX_LINES_RULE2]: [PROBE_SEVERITY, { ...options, max: PROBE_MAX }] };
-}
-function probe_rule(options) {
-  return JSON.stringify(probe_rules(options));
-}
-function cache_prefix(key) {
-  const digest = createHash("sha256").update(key).digest("hex").slice(0, CACHE_KEY_LENGTH);
-  return `${CACHE_PREFIX}${digest}-`;
-}
-function probe_arguments(group, project_root) {
-  return [
-    ...FORMAT_FLAGS,
-    RULE_FLAG,
-    probe_rule(group.options),
-    CACHE_LOCATION_FLAG,
-    stamp_file.stamp_path(cache_prefix(group.key), project_root),
-    ...group.paths
-  ];
-}
-function probe_command(project_root, probe_args) {
-  const shim = find_local_bin_upwards(project_root, ESLINT_BIN);
-  return shim === void 0 ? [PNPM, PNPM_EXEC, ESLINT_BIN, ...probe_args] : [shim, ...probe_args];
-}
-async function run_probe(group, project_root) {
-  const [bin, ...command_arguments] = probe_command(
-    project_root,
-    probe_arguments(group, project_root)
-  );
-  try {
-    const result = await execa(bin ?? PNPM, command_arguments, {
-      cwd: project_root,
-      reject: false,
-      stdout: "pipe",
-      stderr: "ignore",
-      timeout: LINT_TIMEOUT_MS
-    });
-    return result.stdout;
-  } catch {
-    return void 0;
-  }
-}
-function count_in_message(message) {
-  const raw = COUNT_PATTERN.exec(message)?.[COUNT_GROUP];
-  return raw === void 0 ? void 0 : Number(raw);
-}
-function count_in(messages) {
-  const reported = messages.find((message) => message.ruleId === MAX_LINES_RULE2);
-  return reported === void 0 ? void 0 : count_in_message(reported.message);
-}
-function count_or_zero(messages) {
-  const counted = count_in(messages);
-  if (counted !== void 0) return counted;
-  const is_refused = messages.some((message) => message.ruleId === null);
-  return is_refused ? void 0 : NO_CODE_LINES;
-}
-function counts_from(results) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    const code_lines = count_or_zero(result.messages);
-    if (code_lines !== void 0) counts.set(path2.resolve(result.filePath), code_lines);
-  }
-  return counts;
-}
-function parse_counts(raw_output = "null") {
-  const results = json_value.parse_with(raw_output, results_schema);
-  return results === void 0 ? /* @__PURE__ */ new Map() : counts_from(results);
-}
-function is_lintable_path(file_path) {
-  try {
-    return statSync(file_path, { throwIfNoEntry: false })?.isFile() === true;
-  } catch {
-    return false;
-  }
-}
-function lintable_paths(file_paths) {
-  return file_paths.filter((file_path) => is_lintable_path(file_path));
-}
-function options_key(options) {
-  return JSON.stringify(
-    options,
-    Object.keys(options).toSorted((left, right) => left.localeCompare(right))
-  );
-}
-function grouped(options_by_path) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [file_path, options] of options_by_path) {
-    const key = options_key(options);
-    const group = groups.get(key) ?? { key, options, paths: [] };
-    group.paths.push(file_path);
-    groups.set(key, group);
-  }
-  return groups;
-}
-async function counts_for(options_by_path, project_root) {
-  const groups = [];
-  for (const [, group] of grouped(options_by_path)) groups.push(group);
-  const outputs = await Promise.all(
-    groups.map(async (group) => await run_probe(group, project_root))
-  );
-  const counts = /* @__PURE__ */ new Map();
-  for (const output of outputs) {
-    for (const [file_path, code_lines] of parse_counts(output)) counts.set(file_path, code_lines);
-  }
-  return counts;
-}
-function budget_for(code_lines, limit) {
-  if (code_lines === void 0 || limit === void 0) return void 0;
-  return budget_of(code_lines, limit);
-}
-async function budgets_for(file_paths, project_root) {
-  const options = await effective_limit.options_for(lintable_paths(file_paths), project_root);
-  const counts = await counts_for(options, project_root);
-  return file_paths.map((file_path) => {
-    const resolved = path2.resolve(file_path);
-    const code_lines = counts.get(resolved);
-    const limit = options.get(resolved)?.max;
-    return { file_path, limit, budget: budget_for(code_lines, limit) };
-  });
-}
-function describe(budget) {
-  const share = Math.floor(budget.code_lines / budget.limit * PERCENT);
-  const remaining = budget.headroom < NO_HEADROOM ? `${String(-budget.headroom)} over` : `${String(budget.headroom)} to spare`;
-  const counted = `${String(budget.code_lines)}/${String(budget.limit)}`;
-  return `${counted} code lines (${String(share)}%), ${remaining}`;
-}
-function advice(budget) {
-  if (budget.headroom < NO_HEADROOM) return "over the limit: split it before the gate reports it";
-  if (!budget.is_near_limit) return void 0;
-  return "near the limit: declare the splitting plan in Step 0 before writing into it";
-}
-var line_budget = {
-  advice,
-  budget_of,
-  budgets_for,
-  counts_from,
-  describe,
-  grouped,
-  is_lintable_path,
-  near_limit_percent,
-  near_limit_threshold,
-  parse_counts,
-  probe_arguments,
-  probe_command,
-  probe_rule,
-  probe_rules,
-  NEAR_LIMIT_FRACTION
-};
-
-export {
-  effective_limit,
-  line_budget
-};

package/dist/commands/chunk-KODXWMBX.js

@@ -1,77 +0,0 @@
-import {
-  backlogrun_launch
-} from "./chunk-2EZTYLO4.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  run_headless
-} from "./chunk-7C7FOKJK.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  agent_safe_text
-} from "./chunk-3LZXX5GL.js";
-import {
-  durable_state
-} from "./chunk-MPGJ4ONJ.js";
-
-// scripts/run/handoff/run-handoff-launch.ts
-var ROLES = {
-  kickoff: agent_role_profile.SCHEDULER,
-  fullrun: agent_role_profile.WORKER,
-  halfrun: agent_role_profile.WORKER,
-  prrun: agent_role_profile.WORKER,
-  retrospective: agent_role_profile.SCHEDULER
-};
-var ORIGIN_MARKER = "through `josh run:handoff`";
-var PREAMBLE = [
-  `Handed over by another session ${ORIGIN_MARKER}; the brief below is the work it hands over.`,
-  "Nobody answers this session: a question for the person ends it, written as the final message.",
-  "End the final message with the URL of every Issue and pull request this run created."
-].join(" ");
-function role_of(keyword) {
-  return ROLES[keyword];
-}
-function prompt_of(handoff, brief) {
-  return agent_safe_text.printable(`${handoff.line}
-
-${PREAMBLE}
-
-${brief.trim()}`);
-}
-function argv_of(child, environment = process.env) {
-  const chosen = backlogrun_launch.chosen_environment(child.provider, environment);
-  const resolved = agent_role_profile.resolve(child.role, chosen);
-  if (resolved.kind === "rejected") return resolved;
-  return agent_argv.with_profile_in(child.prompt, resolved.profile, child.cwd);
-}
-function log_path(git_directory, keyword, now) {
-  const suffix = `-${keyword}-${String(now)}.log`;
-  return durable_state.path(durable_state.PREFIX.HANDOFF_LOG, git_directory, suffix);
-}
-function request_of(built, cwd, log) {
-  const environment = {
-    ...run_headless.handoff_child_environment(),
-    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
-    [agent_role_profile.HANDED_PROVIDER_KEY]: built.profile.provider
-  };
-  return { argv: built.argv, cwd, env: environment, log_path: log, profile: built.profile };
-}
-function is_waited(keyword) {
-  return keyword === "kickoff" || keyword === "retrospective";
-}
-var run_handoff_launch = {
-  ORIGIN_MARKER,
-  argv_of,
-  is_waited,
-  log_path,
-  prompt_of,
-  request_of,
-  role_of
-};
-
-export {
-  run_handoff_launch
-};

package/dist/commands/chunk-KPSKWTOS.js

@@ -1,208 +0,0 @@
-import {
-  lane_implement_signals
-} from "./chunk-XKSUBUIH.js";
-import {
-  lane_breakdown_related,
-  lane_breakdown_text,
-  lane_ci_path_stats
-} from "./chunk-TLAB552K.js";
-import {
-  ci_timing
-} from "./chunk-LWAXXZPS.js";
-import {
-  git_pr_checks_failed
-} from "./chunk-UOVUUVDK.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  lane_stage_budget
-} from "./chunk-AXXEMVRJ.js";
-import {
-  lane_sinks,
-  lane_sinks_issues
-} from "./chunk-ACZ52JPI.js";
-import {
-  lane_breakdown
-} from "./chunk-MLW4S35K.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-
-// scripts/lane/lane-why-ci.ts
-var BLANK = "";
-var UNMEASURED = -1;
-function seconds_of(row) {
-  return row?.seconds ?? UNMEASURED;
-}
-function longest(rows) {
-  return rows.toSorted((left, right) => seconds_of(right) - seconds_of(left)).find((row) => row.seconds !== void 0);
-}
-function row_text(label, row) {
-  return row === void 0 ? BLANK : `${label}: ${row.name} ${String(row.seconds)}s`;
-}
-function cell(answer) {
-  if (answer?.kind !== "timed") return BLANK;
-  const job = longest(answer.runs.flatMap((run) => run.jobs));
-  if (job === void 0) return BLANK;
-  return [row_text("longest job", job), row_text("step", longest(job.steps))].filter((part) => part !== BLANK).join(", ");
-}
-async function read(issue) {
-  try {
-    return await ci_timing.timing_of(lane_paths.lane_branch(String(issue)));
-  } catch {
-    return void 0;
-  }
-}
-var lane_why_ci = { cell, read };
-
-// scripts/lane/lane-why-causes.ts
-var MAIN_CHANGED = "main changed";
-var KNOWN = [
-  { key: "sonarqube", title: ["sonar"], check: /sonar/iu },
-  {
-    key: "main move",
-    title: ["main moved", MAIN_CHANGED, "merge main"],
-    log: new RegExp(`Not rerunning: ${MAIN_CHANGED}`, "u")
-  },
-  { key: "byte budget", log: /byte budget/iu }
-];
-var NAME_SEPARATOR = ", ";
-function key_of(check) {
-  return KNOWN.find((known) => known.check?.test(check) === true)?.key ?? check.toLowerCase();
-}
-function log_keys(log) {
-  if (log === void 0) return [];
-  const verdicts = KNOWN.filter((known) => known.log?.test(log) === true);
-  const failed = git_pr_checks_failed.names_of(log);
-  return [...failed.map((check) => key_of(check)), ...verdicts.map(({ key }) => key)];
-}
-function keys_of(entries, issue, log) {
-  const longest2 = lane_ci_path_stats.last_check_name(entries, issue);
-  const ledger = longest2 === void 0 ? [] : [key_of(longest2)];
-  return [.../* @__PURE__ */ new Set([...log_keys(log), ...ledger])];
-}
-function issues_of(key, issues) {
-  const words = [key, ...KNOWN.find((known) => known.key === key)?.title ?? []];
-  return issues.filter(
-    (issue) => words.some((word) => issue.title.toLowerCase().includes(word.toLowerCase()))
-  );
-}
-function open_cell(keys, issues) {
-  if (issues === void 0) return lane_sinks_issues.UNREAD;
-  const numbers = new Set(keys.flatMap((key) => issues_of(key, issues)).map(({ number }) => number));
-  return numbers.size === 0 ? lane_sinks_issues.NONE : [...numbers].map((number) => issue_cite.plain_for("linked", number)).join(NAME_SEPARATOR);
-}
-function unfiled_cell(keys, issues) {
-  if (issues === void 0) return lane_sinks_issues.UNREAD;
-  return keys.filter((key) => issues_of(key, issues).length === 0).join(NAME_SEPARATOR);
-}
-var lane_why_causes = { keys_of, issues_of, open_cell, unfiled_cell };
-
-// scripts/lane/lane-why.ts
-var COLUMNS = [
-  "stage",
-  "min",
-  "budget",
-  "projected",
-  "CI",
-  "ship",
-  "causes",
-  "open issues",
-  "unfiled"
-];
-var BLANK2 = "";
-var SHIP_SEPARATOR = "; ";
-var KEY_SEPARATOR = ", ";
-var SHIP_BUDGETS = /* @__PURE__ */ new Set(["ship", "followup"]);
-function projected_of(body, rate, growth) {
-  const estimate = body === void 0 ? void 0 : size_estimate.declared_size(body);
-  if (estimate === void 0 || rate === void 0) return void 0;
-  return size_estimate.projected_minutes(estimate, rate, growth);
-}
-function over_of(stage) {
-  const budget = lane_breakdown_text.budget_of(stage.name);
-  if (budget === void 0) return void 0;
-  return lane_stage_budget.over_minutes(budget, stage.ms) === void 0 ? void 0 : { stage, budget };
-}
-function over_stages(breakdown) {
-  return [...breakdown.stages, ...breakdown.driver ?? []].map((stage) => over_of(stage)).filter((row) => row !== void 0);
-}
-function is_stop(entry, issue) {
-  return entry.kind === lane_ledger.KIND.STOP && entry.issue === issue;
-}
-function ship_cell(records) {
-  const stops = records.entries.filter((entry) => is_stop(entry, records.issue)).map((entry) => entry.reason);
-  const related = lane_breakdown_related.over_cap_text(records.entries, records.issue);
-  return [...stops, related].filter((part) => part !== BLANK2).join(SHIP_SEPARATOR);
-}
-function ci_cell(records) {
-  const last_check = lane_ci_path_stats.last_check_text(records.entries, records.issue).trim();
-  return [last_check, lane_why_ci.cell(records.timing)].filter((part) => part !== BLANK2).join(SHIP_SEPARATOR);
-}
-function projected_cell(records) {
-  return records.projected === void 0 ? BLANK2 : `${records.projected.toFixed(1)} min`;
-}
-function implement_keys(records) {
-  const signals = lane_implement_signals.signals_of(records.events, records.issue);
-  const keys = signals === void 0 ? [] : lane_implement_signals.keys_of(signals);
-  return keys.length === 0 ? void 0 : keys;
-}
-function keys_of2(budget, records) {
-  if (SHIP_BUDGETS.has(budget)) {
-    return lane_why_causes.keys_of(records.entries, records.issue, records.log);
-  }
-  return budget === "implement" ? implement_keys(records) : void 0;
-}
-function cause_cells({ stage, budget }, records) {
-  const keys = keys_of2(budget, records);
-  if (keys === void 0) {
-    return [
-      BLANK2,
-      lane_why_causes.open_cell([lane_sinks.base_name(stage.name)], records.issues),
-      BLANK2
-    ];
-  }
-  return [
-    keys.join(KEY_SEPARATOR),
-    lane_why_causes.open_cell(keys, records.issues),
-    lane_why_causes.unfiled_cell(keys, records.issues)
-  ];
-}
-function row_of(over, records) {
-  const { stage, budget } = over;
-  return lane_stats.to_row([
-    stage.name,
-    lane_breakdown.minutes_text(stage.ms),
-    `${String(lane_stage_budget.BUDGET_MINUTES[budget])} min`,
-    budget === "implement" ? projected_cell(records) : BLANK2,
-    budget === "followup" ? ci_cell(records) : BLANK2,
-    budget === "ship" ? ship_cell(records) : BLANK2,
-    ...cause_cells(over, records)
-  ]);
-}
-function table(records) {
-  const over = over_stages(records.breakdown);
-  if (over.length === 0) return void 0;
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    ...over.map((row) => row_of(row, records))
-  ].join("\n");
-}
-var lane_why = { over_stages, projected_of, table };
-
-export {
-  lane_why_causes,
-  lane_why_ci,
-  lane_why
-};

package/dist/commands/chunk-KVHNQHX3.js

@@ -1,100 +0,0 @@
-import {
-  has_stderr_field
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/git/git-error.ts
-function get_stderr_from_error(cause) {
-  if (!has_stderr_field(cause)) return void 0;
-  const stderr = cause.stderr.trim();
-  return stderr.length > 0 ? stderr : void 0;
-}
-function get_error_message_from_cause(cause) {
-  const message = cause.message.trim();
-  if (message.length > 0) return message;
-  return get_stderr_from_error(cause);
-}
-function get_cause_message(cause) {
-  if (cause instanceof Error) return get_error_message_from_cause(cause);
-  if (typeof cause === "string") return cause.trim();
-  return void 0;
-}
-var FAILURE_PREFIX = "\u274C Error:";
-var DETAILS_PREFIX = "\u{1F4A1} Details:";
-function display_error_details(cause) {
-  const cause_message = get_cause_message(cause);
-  if (cause_message === void 0 || cause_message.length === 0) return;
-  console.error("");
-  console.error(DETAILS_PREFIX, cause_message);
-}
-var FAILURE_EXIT_CODE = 1;
-var OPERATION_CANCELLED_MESSAGE = "\u{1F4A1} Operation cancelled.";
-var BranchMismatchError = class extends Error {
-  current_branch;
-  target_branch_name;
-  constructor(mismatch, options) {
-    super(
-      `Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
-      options
-    );
-    this.name = "BranchMismatchError";
-    this.current_branch = mismatch.current_branch;
-    this.target_branch_name = mismatch.target_branch_name;
-  }
-};
-var OperationCancelledError = class extends Error {
-  constructor() {
-    super("Operation cancelled");
-    this.name = "OperationCancelledError";
-  }
-};
-function display_failure(error) {
-  const error_message = error_text.message_of(error);
-  console.error("");
-  console.error(FAILURE_PREFIX, error_message);
-  if (error instanceof Error && error.cause !== void 0) {
-    display_error_details(error.cause);
-  }
-  console.error("");
-}
-function display_branch_mismatch(error) {
-  console.error("");
-  console.error("\u274C Branch mismatch detected");
-  console.error("");
-  console.error(`Current branch: ${error.current_branch}`);
-  console.error(`Expected branch: ${error.target_branch_name}`);
-  console.error("");
-  console.error("\u{1F4A1} Please update main branch to the latest and try again.");
-}
-function display_cancelled() {
-  console.info(OPERATION_CANCELLED_MESSAGE);
-  console.info("");
-}
-function display(error) {
-  if (error instanceof BranchMismatchError) {
-    display_branch_mismatch(error);
-    return;
-  }
-  if (error instanceof OperationCancelledError) {
-    display_cancelled();
-    return;
-  }
-  display_failure(error);
-}
-function handle(error) {
-  display(error);
-  process.exitCode = FAILURE_EXIT_CODE;
-}
-var git_error = {
-  DETAILS_PREFIX,
-  FAILURE_PREFIX,
-  handle
-};
-
-export {
-  BranchMismatchError,
-  OperationCancelledError,
-  git_error
-};