@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-P43GWYR6.js

@@ -0,0 +1,185 @@
+import {
+  lane_preserve
+} from "./chunk-VMG3QB6C.js";
+import {
+  run_investigation_record
+} from "./chunk-JT5ICRFF.js";
+import {
+  lane_close
+} from "./chunk-XUXCFPDK.js";
+import {
+  lane_residents
+} from "./chunk-43H725LG.js";
+import {
+  issue_state_cli
+} from "./chunk-E4PFCTXN.js";
+import {
+  run_label
+} from "./chunk-KN46UC77.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-withdraw.ts
+var WITHDRAW_OCCASION = "lane withdraw";
+var CLOSED_STATE = "CLOSED";
+var CLOSED_KIND = "closed";
+var NO_LANE_KIND = "no-lane";
+var UNREADABLE_KIND = "unreadable";
+var OPEN_TAIL = "Its lane child was stopped and the lane closed. The Issue stays open: this run does not resume it, and the next run offers it again.";
+var STAYS_OPEN = "The Issue stays open: this run does not offer it again, the next run does.";
+var WITHDRAWER_TEXT = {
+  person: {
+    name: "a person",
+    cause: "a person withdrew it with `lane:withdraw`",
+    closed_head: "Its lane was withdrawn with `pnpm josh lane:withdraw` after the Issue was closed.",
+    open_head: "Withdrawn from the current run by a person with `pnpm josh lane:withdraw`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  supervisor: {
+    name: "the run:wake supervisor",
+    cause: "the `run:wake` supervisor withdrew it after its issue was closed",
+    closed_head: "Its lane was withdrawn by the `run:wake` supervisor after the Issue was closed.",
+    open_head: "Withdrawn from the current run by the `run:wake` supervisor.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  merge: {
+    name: "the run:merge driver",
+    cause: "`run:merge` withdrew it after its issue was closed without a merge",
+    closed_head: "Its lane was withdrawn by `pnpm josh run:merge` after the Issue was closed without a merge.",
+    open_head: "Withdrawn from the current run by `pnpm josh run:merge`.",
+    open_tail: OPEN_TAIL,
+    stays: STAYS_OPEN
+  },
+  yield: lane_yield.YIELD_TEXT
+};
+function withdraw_comment({ reason, by, is_closed }) {
+  const head = is_closed ? WITHDRAWER_TEXT[by].closed_head : WITHDRAWER_TEXT[by].open_head;
+  const tail = is_closed ? "Its lane child was stopped and the lane closed, so it no longer holds a lane and is not resumed." : WITHDRAWER_TEXT[by].open_tail;
+  return [head, tail, `- Why: ${reason}`].join("\n");
+}
+async function record_withdraw(issue, { reason, by }) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.WITHDRAW,
+    `${issue_cite.plain_for("program", issue)} withdrawn by ${WITHDRAWER_TEXT[by].name}: ${reason}`
+  );
+}
+async function read_is_closed(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  if (read.kind !== "state") return void 0;
+  return read.state.state.toUpperCase() === CLOSED_STATE;
+}
+async function forget_investigation(issue, is_closed) {
+  if (!is_closed) return;
+  await run_investigation_record.remove(issue);
+}
+async function note_issue(issue, withdrawal, stash) {
+  const is_noted = await git_gh_issue_write.issue_try_comment(issue, withdraw_comment(withdrawal));
+  if (stash !== void 0) {
+    await lane_preserve.announce(issue, stash, WITHDRAWER_TEXT[withdrawal.by].cause);
+  }
+  await run_label.unmark(issue);
+  await forget_investigation(issue, withdrawal.is_closed);
+  return is_noted;
+}
+async function stop_and_close(lane, withdrawal) {
+  await record_withdraw(lane.issue, withdrawal);
+  const reaped = lane_reap.reap_child(lane).length;
+  const saved = await lane_preserve.keep_work(lane.issue, lane.directory, WITHDRAW_OCCASION);
+  if (saved.kind === "unsaved") return saved;
+  const is_noted = await note_issue(lane.issue, withdrawal, saved.stash);
+  const closed = await lane_close.close_lane(lane.issue);
+  if (closed.kind !== "incomplete") {
+    await lane_state.record_change({ issue: lane.issue, state: "ended", command: "lane:withdraw" });
+  }
+  return {
+    kind: "withdrawn",
+    by: withdrawal.by,
+    reaped,
+    stash: saved.stash,
+    is_noted,
+    is_closed: withdrawal.is_closed,
+    lane: closed.kind,
+    residents: closed.residents
+  };
+}
+async function withdraw(issue, reason, by = "person") {
+  issue_number_shape.require_issue_number(issue);
+  const is_closed = await read_is_closed(issue);
+  if (is_closed === void 0) return { kind: UNREADABLE_KIND };
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: is_closed ? CLOSED_KIND : NO_LANE_KIND };
+  return await stop_and_close(lane, { reason, by, is_closed });
+}
+function stash_sentence(stash) {
+  if (stash === void 0) return "The lane held no uncommitted work.";
+  return `Its uncommitted work was stashed \u2014 recover with \`pnpm josh stash:pop "${stash}"\`.`;
+}
+function lane_suffix(outcome, cited) {
+  const removed = outcome.lane === "incomplete" ? " The lane could not be fully removed." : "";
+  const residents = lane_residents.residents_sentence(outcome.residents, cited);
+  return residents === void 0 ? removed : `${removed} ${residents}`;
+}
+function withdrawn_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  const stopped = outcome.reaped === 0 ? "Its child had already ended." : "Stopped its child.";
+  const head = `Withdrew ${cited}. ${stopped} ${stash_sentence(outcome.stash)}`;
+  const lane = lane_suffix(outcome, cited);
+  const noted = outcome.is_noted ? "" : " The comment saying so could not be posted.";
+  const issue_sentence = outcome.is_closed ? "The Issue was already closed, so its lane no longer holds a place." : WITHDRAWER_TEXT[outcome.by].stays;
+  return `${head} ${issue_sentence}${noted}${lane}`;
+}
+function unsaved_text(outcome, issue) {
+  return `The child for ${session_cite.issue(issue)} was stopped, but its uncommitted work could not be stashed (${outcome.reason}), so the lane is left at ${outcome.directory}; \`run:merge\` books it withdrawn.`;
+}
+function refused_text(outcome, issue) {
+  const cited = session_cite.issue(issue);
+  if (outcome.kind === CLOSED_KIND) {
+    return `${cited} is already closed and no lane is open for it, so there is nothing to withdraw.`;
+  }
+  if (outcome.kind === NO_LANE_KIND) {
+    return `No lane is open for ${cited}, so there is no child to withdraw.`;
+  }
+  return `The state of ${cited} could not be read, so nothing was stopped or closed \u2014 try again.`;
+}
+function describe(outcome, issue) {
+  if (outcome.kind === "unsaved") return unsaved_text(outcome, issue);
+  return outcome.kind === "withdrawn" ? withdrawn_text(outcome, issue) : refused_text(outcome, issue);
+}
+var WITHDRAWER_NAMES = Object.values(WITHDRAWER_TEXT).map(
+  (text) => text.name
+);
+var lane_withdraw = { WITHDRAWER_NAMES, describe, withdraw };
+
+export {
+  lane_withdraw
+};

package/dist/commands/chunk-P6ASP2DY.js

@@ -0,0 +1,132 @@
+import {
+  lane_implement_rate_read
+} from "./chunk-PJYTUUTH.js";
+import {
+  git_path_quoting,
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/split/split-measure.ts
+import { readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/split/split-relocations.ts
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+var PAIR_FIELDS = 2;
+var RAW_OPTIONS = ["diff", "--raw", "-z", "--no-abbrev", "--no-relative", "--no-renames"];
+function raw_changes(raw) {
+  return raw.split("\0").flatMap(
+    (header, index, fields) => index % PAIR_FIELDS === 0 && fields[index + 1] !== void 0 ? { header, file: fields[index + 1] ?? "" } : []
+  );
+}
+function deleted_blobs(raw) {
+  return raw_changes(raw).flatMap(({ header, file }) => {
+    const object = /^:100\d+ \d+ (\w+) \w+ D$/u.exec(header)?.[1];
+    return object === void 0 ? [] : { file, object };
+  });
+}
+function added_paths(raw) {
+  return raw_changes(raw).filter((change) => change.header.endsWith(" A")).map((change) => change.file);
+}
+async function content_object(root, file) {
+  try {
+    const stat = await lstat(path.join(root, file));
+    if (!stat.isFile()) return void 0;
+    return await git_spawn.read(["-C", root, "hash-object", "--no-filters", "--", file]);
+  } catch {
+    return void 0;
+  }
+}
+function pair(deleted, addition) {
+  const index = deleted.findIndex((blob) => blob.object === addition.object);
+  if (index === -1) return [];
+  return deleted.splice(index, 1).flatMap((source) => [source.file, addition.file]);
+}
+function paired_paths(raw, additions) {
+  const deleted = deleted_blobs(raw);
+  const paths = additions.flatMap((addition) => pair(deleted, addition));
+  return new Set(paths.map((file) => git_path_quoting.quote(file)));
+}
+async function candidates(root, files) {
+  return await Promise.all(
+    files.map(async (file) => ({
+      file,
+      object: await content_object(root, file) ?? ""
+    }))
+  );
+}
+async function without_relocations(root, base, numstat, untracked) {
+  const raw = await git_spawn.read([...RAW_OPTIONS, base, "--"]);
+  const added = [...added_paths(raw), ...untracked];
+  const paired = paired_paths(raw, await candidates(root, added));
+  const rows = numstat.split("\n").filter((row) => !paired.has(row.split("	").slice(PAIR_FIELDS).join("	")));
+  return { numstat: rows.join("\n"), added };
+}
+var split_relocations = { without_relocations };
+
+// scripts/split/split-measure.ts
+var UNRESOLVED_BASE = "the change base could not be resolved";
+var NUL_BYTE = 0;
+var NO_CONTENT = Buffer.alloc(0);
+var NEWLINE = "\n";
+function line_count(content) {
+  if (content.includes(NUL_BYTE)) return 0;
+  const text = content.toString("utf8");
+  const newlines = text.split(NEWLINE).length - 1;
+  return text === "" || text.endsWith(NEWLINE) ? newlines : newlines + 1;
+}
+async function read_content(file_path) {
+  try {
+    return await readFile(file_path);
+  } catch {
+    return NO_CONTENT;
+  }
+}
+async function untracked_row(root, file) {
+  const lines = line_count(await read_content(path2.join(root, file)));
+  return `${String(lines)}	0	${git_path_quoting.quote(file)}`;
+}
+async function untracked_numstat(root, files) {
+  const rows = await Promise.all(files.map(async (file) => await untracked_row(root, file)));
+  return rows.join(NEWLINE);
+}
+async function read_guide() {
+  const measured = await lane_implement_rate_read.measurements();
+  return split_assess.guide_for(
+    lane_stage_budget.BUDGET_MINUTES.implement,
+    measured.implement_rate,
+    measured.growth
+  );
+}
+async function read_branch() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) throw new Error(UNRESOLVED_BASE);
+  const tracked = await git_command.diff_numstat_since(base);
+  const files = changed_paths.to_paths(await git_command.untracked_names()).map((file) => git_path_quoting.unquote(file));
+  const toplevel = await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const root = toplevel.trim();
+  const numstat = `${tracked}${NEWLINE}${await untracked_numstat(root, files)}`;
+  const adjusted = await split_relocations.without_relocations(root, base, numstat, files);
+  return split_assess.assess(adjusted.numstat, await read_guide(), new Set(adjusted.added));
+}
+var split_measure = { line_count, read_branch };
+
+export {
+  split_measure
+};

package/dist/commands/chunk-PBAEJ5PT.js

@@ -0,0 +1,38 @@
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/gate/moved-paths.ts
+var NAME_SEPARATOR = "\0";
+var BASE_DIFF = ["diff", "--name-only", "--no-renames", "-z"];
+async function base_diff(from, to) {
+  if (from === to) return [];
+  try {
+    const names = await git_spawn.read([...BASE_DIFF, from, to]);
+    return names.split(NAME_SEPARATOR).filter((name) => name !== "");
+  } catch {
+    return void 0;
+  }
+}
+async function moved_parts(stamp, tree) {
+  const is_unread = Object.keys(tree.files).length === 0;
+  if (is_unread || stamp.base === void 0 || tree.base === void 0) return void 0;
+  const synced = await base_diff(stamp.base, tree.base);
+  if (synced === void 0) return void 0;
+  return { changed: file_map_stamp.changed_since(stamp, tree.files), synced };
+}
+function union_of(parts) {
+  return [.../* @__PURE__ */ new Set([...parts.changed, ...parts.synced])];
+}
+async function moved_since(stamp, tree) {
+  const parts = await moved_parts(stamp, tree);
+  return parts === void 0 ? void 0 : union_of(parts);
+}
+var moved_paths = { moved_parts, moved_since, union_of };
+
+export {
+  moved_paths
+};

package/dist/commands/chunk-PCZROH3R.js

@@ -0,0 +1,100 @@
+import {
+  issue_observation_gate
+} from "./chunk-YJZAD4Z5.js";
+import {
+  issue_sample_gate
+} from "./chunk-CQUZ6TNQ.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/issue/issue-not-before.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var PREFIX = issue_body_keys.prefix("not_before");
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u;
+var ISO_TAIL = ":00.000Z";
+var EXAMPLE = `${PREFIX} 2099-01-01T09:00Z`;
+var MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ
+${EXAMPLE}`;
+var MAX_WAIT_DAYS = 7;
+var DAY_MS = 864e5;
+var MAX_WAIT_MS = MAX_WAIT_DAYS * DAY_MS;
+var MINUTES_LENGTH = 16;
+var TOO_LATE = `\`${PREFIX}\` of a measurement follow-up must be at most ${String(MAX_WAIT_DAYS)} days after filing \u2014 wait on samples with \`${issue_sample_gate.DECLARATION}\` instead`;
+var BOTH = `a measurement follow-up declares one of \`${PREFIX}\` and \`${issue_body_keys.prefix("sample_gate")}\`, not both \u2014 keep the condition`;
+var HEADING_MARKS = /^#{1,6}\s+/u;
+var STRAY_HEADINGS = [
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u65E5", declaration: `${PREFIX} YYYY-MM-DDTHH:MMZ` },
+  { name: "\u5B9F\u65BD\u53EF\u80FD\u6761\u4EF6", declaration: issue_sample_gate.DECLARATION }
+];
+function declared_value(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  const line = markdown_section.unfenced_lines(background).map((text) => text.trim()).find((text) => text.startsWith(PREFIX));
+  return line?.slice(PREFIX.length).trim();
+}
+function is_valid(value) {
+  if (!DATE_PATTERN.test(value)) return false;
+  const time = Date.parse(value);
+  return !Number.isNaN(time) && new Date(time).toISOString() === `${value.slice(0, -1)}${ISO_TAIL}`;
+}
+function date_of(body = "") {
+  const value = declared_value(body);
+  return value !== void 0 && is_valid(value) ? value : void 0;
+}
+function is_date_due(body, now) {
+  const date = date_of(body);
+  return date === void 0 || Date.parse(date) <= now;
+}
+function is_due(body, now = Date.now()) {
+  return is_date_due(body, now) && issue_sample_gate.wait_of(body) === void 0 && issue_observation_gate.wait_of(body) === void 0;
+}
+function waiting_ms(body, now = Date.now()) {
+  if (is_date_due(body, now)) return void 0;
+  return Date.parse(String(date_of(body)));
+}
+function waiting_date(body, now = Date.now()) {
+  return is_date_due(body, now) ? void 0 : date_of(body);
+}
+function waiting_reason(body, now = Date.now()) {
+  const date = waiting_date(body, now);
+  if (date !== void 0) return `not before ${date}`;
+  const wait = issue_sample_gate.wait_of(body);
+  return wait === void 0 ? issue_observation_gate.wait_of(body)?.reason : issue_sample_gate.reason_of(wait);
+}
+function stray_heading_problems(body) {
+  const headings = markdown_section.unfenced_lines(body).map((line) => line.trim()).filter((line) => HEADING_MARKS.test(line)).map((line) => line.replace(HEADING_MARKS, ""));
+  return STRAY_HEADINGS.filter(({ name }) => headings.some((text) => text.startsWith(name))).map(
+    ({ name, declaration }) => `heading \`${name}\` is not read \u2014 declare it under \`${BACKGROUND_HEADING}\` as \`${declaration}\``
+  );
+}
+function latest_date(now) {
+  return `${new Date(now + MAX_WAIT_MS).toISOString().slice(0, MINUTES_LENGTH)}Z`;
+}
+function measurement_wait_problems(body, now) {
+  const date = date_of(body);
+  if (date === void 0 || !measure_declaration.is_stated(body)) return [];
+  if (issue_sample_gate.cited_number(body) !== void 0) return [BOTH];
+  return Date.parse(date) > now + MAX_WAIT_MS ? [`${TOO_LATE}
+${PREFIX} ${latest_date(now)}`] : [];
+}
+function problems(body, now = Date.now()) {
+  const value = declared_value(body);
+  const date_problems = value === void 0 || is_valid(value) ? [] : [MALFORMED];
+  return [
+    ...stray_heading_problems(body),
+    ...date_problems,
+    ...measurement_wait_problems(body, now),
+    ...issue_sample_gate.problems(body)
+  ];
+}
+var issue_not_before = { is_due, problems, waiting_date, waiting_ms, waiting_reason };
+
+export {
+  issue_not_before
+};

package/dist/commands/chunk-PJYTUUTH.js

@@ -0,0 +1,34 @@
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-KP2BVAS5.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+
+// scripts/lane/lane-implement-rate-read.ts
+var PERIOD_DAYS = 3;
+async function read_ledger(context) {
+  const path = context.ledger_path ?? await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function implement_rate(context = {}, now_ms = Date.now()) {
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return lane_implement_rate.rate(await read_ledger(context), window);
+}
+async function measurements(context = {}, now_ms = Date.now()) {
+  const entries = await read_ledger(context);
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return {
+    implement_rate: lane_implement_rate.rate(entries, window),
+    growth: lane_size_stats.ratios(entries, window)
+  };
+}
+var lane_implement_rate_read = { PERIOD_DAYS, implement_rate, measurements, read_ledger };
+
+export {
+  lane_implement_rate_read
+};

package/dist/commands/chunk-PKXTISWR.js

@@ -0,0 +1,58 @@
+import {
+  git_issue
+} from "./chunk-QTVVFV4Q.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+
+// scripts/run/ship/run-ship-planned.ts
+import path from "node:path";
+var PRECONDITION = "unplanned";
+var SEPARATOR = "/";
+var NON_CODE_PREFIXES = ["docs/", ".josh/"];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".js", ".mjs", ".sh", ".svelte", ".ts"]);
+function is_planned(claims, file) {
+  return claims.some(
+    (claim) => claim.endsWith(SEPARATOR) ? file.startsWith(claim) : claim === file
+  );
+}
+function is_code(file) {
+  return CODE_EXTENSIONS.has(path.extname(file)) && NON_CODE_PREFIXES.every((prefix) => !file.startsWith(prefix));
+}
+function unplanned_of(claims, changed) {
+  return test_declared_logic.runtime_files(changed).filter((file) => is_code(file) && !is_planned(claims, file));
+}
+function problem_text(issue, claims, files) {
+  const replan = ["pnpm josh lane:plan", issue, ...claims, ...files].join(" ");
+  return `unplanned: ${files.join(", ")} \u2014 the lane's lane:plan record does not list these code files. In scope: run \`${replan}\` and comment the reason on the Issue in one line, then re-detach; if it answers \`yield\` or \`split\`, follow what it prints instead. Out of scope: revert the change and file it with \`pnpm josh issue:file\`.`;
+}
+function held_claims(plan) {
+  return plan?.yielded === true ? void 0 : plan?.paths;
+}
+async function unplanned() {
+  const issue = git_issue.branch_number(await git_branch.current());
+  if (issue === void 0) return void 0;
+  const claims = held_claims(lane_plan.read(Number(issue), process.cwd()));
+  if (claims === void 0) return void 0;
+  const files = unplanned_of(claims, await changed_paths.read_changed_paths(false));
+  if (files.length === 0) return void 0;
+  return { issue: Number(issue), files, text: problem_text(issue, claims, files) };
+}
+async function problems() {
+  const found = await unplanned();
+  return found === void 0 ? [] : [found.text];
+}
+var run_ship_planned = { PRECONDITION, problems, unplanned, unplanned_of };
+
+export {
+  run_ship_planned
+};

package/dist/commands/chunk-PSGLUBSB.js

@@ -0,0 +1,74 @@
+import {
+  issue_outcome
+} from "./chunk-2WRDAQPJ.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-comment-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var BODY_FLAG = "--body";
+var BODY_FILE_FLAG = "--body-file";
+var USAGE = `Usage: josh issue:comment <issue-number> ${BODY_FLAG} <text> | ${BODY_FILE_FLAG} <path>`;
+var OPTIONS = {
+  body: { type: "string" },
+  "body-file": { type: "string" },
+  outcome: { type: "string" },
+  "evidence-url": { type: "string" }
+};
+function parse_request(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue_number = issue_number_shape.single_of(parsed.positionals);
+  if (issue_number === void 0) return void 0;
+  const body = cli_body.resolve({
+    inline: parsed.values.body,
+    file_path: parsed.values["body-file"],
+    inline_flag: BODY_FLAG,
+    file_flag: BODY_FILE_FLAG
+  });
+  if (body === void 0 || body.length === 0) return void 0;
+  return {
+    issue_number,
+    body: issue_outcome.body_of({
+      body,
+      summary: parsed.values.outcome,
+      url: parsed.values["evidence-url"]
+    })
+  };
+}
+function resolve_request(argv, usage = USAGE) {
+  try {
+    const request = parse_request(argv);
+    if (request === void 0) console.error(usage);
+    return request;
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return void 0;
+  }
+}
+async function run(argv) {
+  const request = resolve_request(argv);
+  if (request === void 0) return FAILURE_EXIT_CODE;
+  const url = await git_gh_command.issue_comment(request.issue_number, request.body);
+  console.info(url);
+  return SUCCESS_EXIT_CODE;
+}
+var issue_comment_cli = { USAGE, resolve_request, run };
+
+export {
+  issue_comment_cli
+};