@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-FM7VVAK6.js

@@ -0,0 +1,426 @@
+import {
+  epic_bundle,
+  epic_bundle_cli
+} from "./chunk-S4JE63QE.js";
+import {
+  epic_bundle_gaps
+} from "./chunk-RFIOZTXY.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  PAGE_CEILING_CAUSE
+} from "./chunk-DACNQAXC.js";
+import {
+  epic_audit_logic
+} from "./chunk-ILIITIMQ.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  EPIC_LABEL,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_citation,
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_array_or_undefined
+} from "./chunk-43DU7DYZ.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-scout.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "can",
+  "do",
+  "for",
+  "from",
+  "has",
+  "have",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "so",
+  "than",
+  "that",
+  "the",
+  "then",
+  "this",
+  "to",
+  "was",
+  "when",
+  "which",
+  "with",
+  "without"
+]);
+var TOKEN_SEPARATOR = /[^a-z\d]+/u;
+var MIN_TOKEN_LENGTH = 2;
+var DICE_NUMERATOR_FACTOR = 2;
+var SIMILARITY_THRESHOLD = 0.35;
+var MIN_SHARED_TOKENS = 2;
+var MAX_CANDIDATES = 5;
+function is_significant(word) {
+  return word.length >= MIN_TOKEN_LENGTH && !STOP_WORDS.has(word);
+}
+function tokenize(text) {
+  const words = text.toLowerCase().split(TOKEN_SEPARATOR);
+  return new Set(words.filter((word) => is_significant(word)));
+}
+function shared_tokens(left, right) {
+  return [...left].filter((token) => right.has(token)).length;
+}
+function dice_similarity(left, right) {
+  const total = left.size + right.size;
+  if (total === 0) return 0;
+  return DICE_NUMERATOR_FACTOR * shared_tokens(left, right) / total;
+}
+function qualifying_score(query, tokens) {
+  if (shared_tokens(query, tokens) < MIN_SHARED_TOKENS) return void 0;
+  const score = dice_similarity(query, tokens);
+  return score < SIMILARITY_THRESHOLD ? void 0 : score;
+}
+function to_epic_field(epic) {
+  return epic === void 0 ? {} : { epic };
+}
+function to_closed_field(is_closed) {
+  return is_closed === true ? { is_closed: true } : {};
+}
+function candidate_score(query, issue, references) {
+  const score = qualifying_score(query, tokenize(issue.title ?? ""));
+  if (score !== void 0) return score;
+  return references.has(issue.number) ? 0 : void 0;
+}
+function to_reference_field(is_referenced) {
+  return is_referenced ? { is_referenced: true } : {};
+}
+function to_candidate(query, issue, references) {
+  if (issue.is_epic === true) return void 0;
+  const score = candidate_score(query, issue, references);
+  if (score === void 0) return void 0;
+  return {
+    number: issue.number,
+    title: issue.title ?? "",
+    score,
+    ...to_reference_field(references.has(issue.number)),
+    ...to_epic_field(issue.epic),
+    ...to_closed_field(issue.is_closed)
+  };
+}
+function compare_candidates(left, right) {
+  const match_order = Number(right.score > 0) - Number(left.score > 0);
+  const reference_order = Number(right.is_referenced === true) - Number(left.is_referenced === true);
+  return match_order || reference_order || right.score - left.score;
+}
+function first_per_number(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    if (seen.has(candidate.number)) return false;
+    seen.add(candidate.number);
+    return true;
+  });
+}
+function find_duplicates(title, issues, referenced_numbers = []) {
+  const query = tokenize(title);
+  const references = new Set(referenced_numbers);
+  const matched = first_per_number(
+    issues.flatMap((issue) => to_candidate(query, issue, references) ?? []).toSorted(compare_candidates)
+  );
+  return { candidates: matched.slice(0, MAX_CANDIDATES), total: matched.length };
+}
+var issue_scout = {
+  SIMILARITY_THRESHOLD,
+  MAX_CANDIDATES,
+  tokenize,
+  dice_similarity,
+  find_duplicates
+};
+
+// scripts/issue/issue-scout-closed.ts
+import { z } from "zod";
+var CLOSED_LIMIT = 100;
+var EPIC_LABELS = /* @__PURE__ */ new Set([EPIC_LABEL]);
+var closed_labels_schema = z.array(issue_label_schema).optional();
+var closed_row_schema = z.object({
+  number: z.number(),
+  title: z.string().nullable(),
+  labels: closed_labels_schema
+});
+function to_closed_row(row) {
+  return {
+    number: row.number,
+    title: row.title ?? "",
+    is_closed: true,
+    // A closed epic is still a container, and `epic_bundle_cli`'s marking cannot reach it: that one
+    // is built from the *open* epic listing. Reported as a duplicate it reads as "this work is
+    // already done" against an epic that never had an implementation of its own.
+    is_epic: has_any_label(row.labels, EPIC_LABELS)
+  };
+}
+function to_closed_rows(json) {
+  const rows = parse_json_array_or_undefined(json, closed_row_schema);
+  return rows?.map((row) => to_closed_row(row));
+}
+async function read_recently_closed() {
+  const { json, is_capped } = await git_gh_command.issue_list_recently_closed(CLOSED_LIMIT);
+  return { rows: json === void 0 ? void 0 : to_closed_rows(json), is_capped };
+}
+var CLOSED_UNREADABLE_LINE = "\u26A0 The recently closed issues could not be read, so the scan below covers open issues only \u2014 work that finished hours ago will not appear in it.";
+var CLOSED_CEILING_LINE = `\u26A0 The recently closed listing ${PAGE_CEILING_CAUSE}, so a duplicate that closed inside the window may not be below.`;
+function warn_about_closed(scan) {
+  if (scan.rows === void 0) {
+    console.error(CLOSED_UNREADABLE_LINE);
+    return;
+  }
+  if (scan.is_capped) console.error(CLOSED_CEILING_LINE);
+}
+var issue_scout_closed = {
+  CLOSED_CEILING_LINE,
+  CLOSED_UNREADABLE_LINE,
+  read_recently_closed,
+  warn_about_closed
+};
+
+// scripts/issue/measure-twin.ts
+function key_of(body) {
+  const declaration = measure_declaration.parse(body);
+  return declaration === void 0 ? void 0 : measure_declaration.format(declaration);
+}
+function twins_of(body, issues) {
+  const key = key_of(body);
+  if (key === void 0) return [];
+  return issues.filter((issue) => key_of(issue.body) === key).map((issue) => issue.number);
+}
+function problem(twins) {
+  if (twins.length === 0) return void 0;
+  const listed = twins.map((twin) => session_cite.issue(twin)).join(", ");
+  return `open issue(s) ${listed} already declare this \`${measure_declaration.PREFIX}\` \u2014 do not file it again; add this change to that issue's acceptance criteria with \`pnpm josh issue:comment <N>\`.`;
+}
+var measure_twin = {
+  problem,
+  twins_of
+};
+
+// scripts/issue/issue-scout-cli.ts
+var { CLOSED_CEILING_LINE: CLOSED_CEILING_LINE2, CLOSED_UNREADABLE_LINE: CLOSED_UNREADABLE_LINE2, read_recently_closed: read_recently_closed2, warn_about_closed: warn_about_closed2 } = issue_scout_closed;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var SCORE_DIGITS = 2;
+var USAGE = 'Usage: josh issue:scout "<title>" [--body "<draft>" | --body-file <path>]';
+var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote`, so the backlog cannot be scanned \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
+var DRAFT_NUMBER = 0;
+function has_invalid_arguments(title, body, body_file) {
+  return title === void 0 || title.trim() === "" || body !== void 0 && body_file !== void 0;
+}
+function read_arguments(argv) {
+  const parsed = cli_flags.parse_or_undefined({
+    args: [...argv],
+    options: { body: { type: "string" }, "body-file": { type: "string" } },
+    allowPositionals: true
+  });
+  if (parsed === void 0) return void 0;
+  const { values, positionals } = parsed;
+  const [title] = positionals;
+  if (title === void 0 || has_invalid_arguments(title, values.body, values["body-file"])) {
+    return void 0;
+  }
+  return { title, body: values.body ?? "", body_file: values["body-file"] };
+}
+function with_draft_body(args) {
+  if (args.body_file === void 0) return args;
+  const read = cli_body.read_result(args.body_file);
+  if ("text" in read) return { ...args, body: read.text };
+  console.error(read.problem);
+  return void 0;
+}
+function draft_of(args, repo) {
+  return {
+    number: DRAFT_NUMBER,
+    repo,
+    title: args.title,
+    body: args.body,
+    blocked_by: []
+  };
+}
+function score_label(candidate) {
+  const score = candidate.score.toFixed(SCORE_DIGITS);
+  if (candidate.is_referenced !== true) return score;
+  return candidate.score > 0 ? `ref ${score}` : "ref";
+}
+function format_duplicate(candidate) {
+  const score = score_label(candidate);
+  const epic = candidate.epic === void 0 ? "" : ` (epic ${session_cite.issue(candidate.epic)})`;
+  const closed = candidate.is_closed === true ? " (closed)" : "";
+  return `  ${session_cite.issue(candidate.number)}  ${score}  ${candidate.title}${closed}${epic}`;
+}
+var NO_DUPLICATE_LINE = "Duplicates: none \u2014 no open or recently closed issue's title shares enough of this one's words to be worth reading.";
+var INCOMPLETE_DUPLICATE_LINE = "Duplicates: incomplete \u2014 an issue listing or referenced issue could not be fully read; inspect the gaps before filing.";
+function duplicates_headline(shown, total) {
+  const suffix = total > shown ? ` of ${String(total)}` : "";
+  return `Duplicates: ${String(shown)}${suffix} candidate(s) \u2014 read these before filing.`;
+}
+function format_duplicates(found) {
+  const { candidates } = found;
+  if (candidates.length === 0) return NO_DUPLICATE_LINE;
+  return [
+    duplicates_headline(candidates.length, found.total),
+    ...candidates.map((candidate) => format_duplicate(candidate))
+  ].join("\n");
+}
+var NO_EPIC_LINE = "Epic: none \u2014 file it standalone; nothing open shares a reference with it.";
+function format_epic(decision) {
+  const lines = [`Epic: ${epic_bundle_cli.ACTION_LINES[decision.action] ?? ""}`];
+  if (decision.epic !== void 0) lines.push(`  Target epic: ${session_cite.issue(decision.epic)}`);
+  if (decision.candidates.length > 0) {
+    lines.push(`  Related: ${epic_bundle_cli.format_numbers(decision.candidates)}`);
+  }
+  return [...lines, ...epic_bundle_cli.format_epics(decision)];
+}
+var NO_REFERENCE_LINE = `Epic: not asked \u2014 no issue number in the summary's acceptance criteria or parent line. Pass --body "parent: #<N>", or take the epic printed beside a duplicate above.`;
+function format_unconfirmed_epic(decision) {
+  const related = epic_bundle_cli.format_numbers(decision.candidates);
+  return `Epic: ${epic_bundle_gaps.unconfirmed_membership(related).join("\n")}`;
+}
+function format_epic_decision(decision, has_citation, is_membership_established) {
+  if (!has_citation) return NO_REFERENCE_LINE;
+  if (decision.action === "none") return NO_EPIC_LINE;
+  if (!is_membership_established) return format_unconfirmed_epic(decision);
+  return format_epic(decision).join("\n");
+}
+function signal_numbers(draft) {
+  return epic_audit_logic.signal_references(draft.body, draft.repo).map((reference) => reference.number);
+}
+function named_epics(draft, issues) {
+  const named = new Set(signal_numbers(draft));
+  return issues.filter((issue) => issue.is_epic === true && named.has(issue.number)).map((issue) => issue.number);
+}
+function format_named_epics(epics, decision) {
+  const lines = [
+    `Epic: the summary names ${epic_bundle_cli.format_numbers(epics)} \u2014 add it there (Tier A \u2014 do it).`
+  ];
+  if (decision.candidates.length === 0) return lines;
+  return [...lines, `  Related: ${epic_bundle_cli.format_numbers(decision.candidates)}`];
+}
+function format_epic_answer(draft, decision, issues, is_membership_established) {
+  const named = named_epics(draft, issues);
+  if (named.length > 0) return format_named_epics(named, decision).join("\n");
+  return format_epic_decision(decision, signal_numbers(draft).length > 0, is_membership_established);
+}
+function duplicates_of(draft, issues, closed) {
+  const references = epic_audit_logic.parse_references(draft.body, draft.repo);
+  return issue_scout.find_duplicates(draft.title ?? "", [...issues, ...closed], references);
+}
+function format_report(draft, issues, is_membership_established, closed = []) {
+  const decision = epic_bundle.decide_bundle(draft, issues);
+  return [
+    format_duplicates(duplicates_of(draft, issues, closed)),
+    format_epic_answer(draft, decision, issues, is_membership_established)
+  ].join("\n");
+}
+function is_duplicate_scan_incomplete(widened, closed) {
+  const has_open_gap = widened.cutoff !== void 0 && widened.cutoff !== "none";
+  return widened.unreadable.length > 0 || has_open_gap || closed.rows === void 0 || closed.is_capped;
+}
+function qualify_duplicate_report(report_text, is_incomplete) {
+  if (!is_incomplete) return report_text;
+  const details = report_text.startsWith(NO_DUPLICATE_LINE) ? report_text.slice(NO_DUPLICATE_LINE.length).trimStart() : report_text;
+  return `${INCOMPLETE_DUPLICATE_LINE}
+${details}`;
+}
+function linkified_report(draft, widened, closed, repo) {
+  const report_text = format_report(
+    draft,
+    widened.issues,
+    epic_bundle_gaps.is_membership_established(widened.epic_cutoff),
+    closed.rows ?? []
+  );
+  const qualified = qualify_duplicate_report(
+    report_text,
+    is_duplicate_scan_incomplete(widened, closed)
+  );
+  return issue_citation.linkify(qualified, repo);
+}
+async function scout(args, repo) {
+  const backlog = await epic_bundle_cli.read_backlog(repo, { include_relations: false });
+  if (!backlog.is_readable) {
+    console.error(epic_bundle_cli.unreadable_backlog_message(backlog));
+    return void 0;
+  }
+  const draft = draft_of(args, repo);
+  const [widened, closed] = await Promise.all([
+    epic_bundle_cli.widen_with_referenced(draft, backlog),
+    read_recently_closed2()
+  ]);
+  epic_bundle_cli.warn_about_gaps(widened);
+  warn_about_closed2(closed);
+  const duplicates = duplicates_of(draft, widened.issues, closed.rows ?? []);
+  return {
+    report: linkified_report(draft, widened, closed, repo),
+    candidates: duplicates.candidates.filter((candidate) => candidate.score > 0).map((candidate) => candidate.number),
+    measure_twins: measure_twin.twins_of(args.body, backlog.issues)
+  };
+}
+async function report(args, repo) {
+  const outcome = await scout(args, repo);
+  if (outcome === void 0) return FAILURE_EXIT_CODE;
+  console.info(outcome.report);
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const parsed = read_arguments(argv);
+  const args = parsed === void 0 ? void 0 : with_draft_body(parsed);
+  if (args === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) {
+    console.error(UNKNOWN_REPO_MESSAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await report(args, repo);
+}
+var issue_scout_cli = {
+  USAGE,
+  UNKNOWN_REPO_MESSAGE,
+  NO_DUPLICATE_LINE,
+  INCOMPLETE_DUPLICATE_LINE,
+  NO_EPIC_LINE,
+  NO_REFERENCE_LINE,
+  CLOSED_UNREADABLE_LINE: CLOSED_UNREADABLE_LINE2,
+  CLOSED_CEILING_LINE: CLOSED_CEILING_LINE2,
+  format_epic,
+  read_arguments,
+  with_draft_body,
+  scout,
+  run
+};
+
+export {
+  measure_twin,
+  issue_scout_cli
+};

package/dist/commands/chunk-FQWRM5FC.js

@@ -0,0 +1,67 @@
+import {
+  issue_fold
+} from "./chunk-QTJPCXEW.js";
+import {
+  split_measure
+} from "./chunk-P6ASP2DY.js";
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  path_decision
+} from "./chunk-JI2EGXZX.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-fold-cli.ts
+var USAGE = 'Usage: josh issue:fold "<title>" "<title>" \u2026 [--not-separable] [--json]';
+var JSON_KEY = "fold";
+var FAILURE_EXIT_CODE = 1;
+var REASONS = {
+  fold: "fold \u2014 file one Issue covering these findings; the split guide is not cleared, so they are one Issue however separable",
+  separate: "separate \u2014 file these apart; they are separable and their combined size clears the split guide",
+  "no-fold-needed": "no fold needed \u2014 a single candidate is filed on its own",
+  undetermined: 'undetermined \u2014 the diff measures no size, so the whole request\'s estimate decides (`split-assessment.md` \u2192 "The question")'
+};
+function read_arguments(argv) {
+  const parsed = cli_flags.parse_or_undefined({
+    args: [...argv],
+    options: { json: { type: "boolean" }, "not-separable": { type: "boolean" } },
+    allowPositionals: true
+  });
+  if (parsed === void 0) return void 0;
+  return {
+    titles: parsed.positionals,
+    is_separable: parsed.values["not-separable"] !== true,
+    is_json: parsed.values.json === true
+  };
+}
+async function size_verdict() {
+  try {
+    const measurement = await split_measure.read_branch();
+    return measurement.files === 0 ? void 0 : measurement.verdict;
+  } catch {
+    return void 0;
+  }
+}
+async function size_for(args) {
+  if (args.titles.length < issue_fold.MIN_CANDIDATES) return split_assess.SINGLE_VERDICT;
+  return await size_verdict();
+}
+async function run(argv) {
+  const args = read_arguments(argv);
+  if (args === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const size = await size_for(args);
+  const verdict = issue_fold.fold_verdict(args.titles.length, args.is_separable, size);
+  path_decision.print_decision(JSON_KEY, verdict, REASONS[verdict], args.is_json);
+  return 0;
+}
+var issue_fold_cli = { REASONS, read_arguments, size_verdict, run };
+
+export {
+  issue_fold_cli
+};