@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-N5FT5LYP.js

@@ -0,0 +1,272 @@
+import {
+  LEDGER_FILE_EXTENSION,
+  LEGACY_LEDGER_FILE,
+  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
+  LEGACY_OBSERVATION_LEDGER_PATHS,
+  MIGRATION_CLAIM_SUFFIX,
+  OBSERVATION_LEDGER_DIRECTORY,
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/observations/observation-ledger-line.ts
+var KEY_PREFIX = "- k:";
+var FIELD_SEPARATOR = " | ";
+var FIELD_COUNT = 5;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var DEPTH_PATTERN = /^d[1-9]\d*$/u;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+var SLUG_REASON = "the slug must be lowercase words joined by `-`";
+var DEPTH_REASON = "the depth must be `d1` or higher (never `d0`)";
+var DATE_REASON = "the date must be `YYYY-MM-DD`";
+var WHERE_REASON = "the `where` field is empty";
+var WHAT_REASON = "the `what` field is empty";
+function is_ledger_entry_line(line) {
+  return line.trimStart().startsWith(KEY_PREFIX);
+}
+function slug_of(first_field) {
+  return first_field.trimStart().slice(KEY_PREFIX.length);
+}
+function is_present(field = "") {
+  return field.trim().length > 0;
+}
+function matches(pattern, field = "") {
+  return pattern.test(field);
+}
+function slug_ok(key_field = "") {
+  return SLUG_PATTERN.test(slug_of(key_field));
+}
+function field_reason(fields) {
+  const [key_field, depth, date, where, what] = fields;
+  const checks = [
+    [slug_ok(key_field), SLUG_REASON],
+    [matches(DEPTH_PATTERN, depth), DEPTH_REASON],
+    [matches(DATE_PATTERN, date), DATE_REASON],
+    [is_present(where), WHERE_REASON],
+    [is_present(what), WHAT_REASON]
+  ];
+  return checks.find(([is_valid]) => !is_valid)?.[1];
+}
+function line_reason(line) {
+  const fields = line.split(FIELD_SEPARATOR);
+  if (fields.length !== FIELD_COUNT) {
+    return `expected ${String(FIELD_COUNT)} fields separated by " | " (a \`|\` in the last field is not allowed)`;
+  }
+  return field_reason(fields);
+}
+function broken_ledger_lines(content) {
+  return content.split("\n").filter((line) => is_ledger_entry_line(line)).map((line) => ({ line, reason: line_reason(line) })).filter((entry) => entry.reason !== void 0);
+}
+function missing_lines(candidates, ledger) {
+  const present = new Set(ledger.split("\n"));
+  return candidates.filter((line) => !present.has(line));
+}
+var observation_ledger_line = {
+  broken_ledger_lines,
+  is_ledger_entry_line,
+  line_reason,
+  missing_lines
+};
+
+// scripts/observations/observation-ledger-home.ts
+import { appendFile, mkdir, readdir, readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/observations/observation-ledger-migrate.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmdirSync,
+  rmSync
+} from "node:fs";
+import path from "node:path";
+var NEWLINE = "\n";
+function claim_path(legacy) {
+  return `${legacy}.${String(process.pid)}${MIGRATION_CLAIM_SUFFIX}`;
+}
+function claim(from, to) {
+  try {
+    renameSync(from, to);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function is_stale_claim(name, legacy_name) {
+  const prefix = `${legacy_name}.`;
+  if (!name.startsWith(prefix) || !name.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
+  const pid = Number(name.slice(prefix.length, -MIGRATION_CLAIM_SUFFIX.length));
+  return Number.isSafeInteger(pid) && !process_identity.is_present_pid(pid);
+}
+function stale_claims(legacy) {
+  const directory = path.dirname(legacy);
+  try {
+    return readdirSync(directory).filter((name) => is_stale_claim(name, path.basename(legacy))).map((name) => path.join(directory, name));
+  } catch {
+    return [];
+  }
+}
+function terminated(content) {
+  return content.length === 0 || content.endsWith(NEWLINE) ? content : `${content}${NEWLINE}`;
+}
+function carried(content, ledger) {
+  if (ledger === void 0) return terminated(content);
+  const lines = content.split(NEWLINE).filter((line) => line.length > 0);
+  const missing = observation_ledger_line.missing_lines(lines, ledger);
+  return missing.length === 0 ? "" : `${missing.join(NEWLINE)}${NEWLINE}`;
+}
+function absorb(claimed, target) {
+  mkdirSync(path.dirname(target), { recursive: true });
+  appendFileSync(
+    target,
+    carried(readFileSync(claimed, "utf8"), file_reader.read_if_readable(target)),
+    "utf8"
+  );
+  rmSync(claimed);
+}
+function absorb_stale(legacy, target) {
+  let count = 0;
+  for (const stale of stale_claims(legacy)) {
+    const claimed = claim_path(legacy);
+    if (!claim(stale, claimed)) continue;
+    absorb(claimed, target);
+    count += 1;
+  }
+  return count;
+}
+function migrate_one(legacy, target) {
+  const recovered = absorb_stale(legacy, target);
+  const claimed = claim_path(legacy);
+  if (!claim(legacy, claimed)) return recovered > 0;
+  absorb(claimed, target);
+  return true;
+}
+function source_name(name) {
+  const end = name.indexOf(LEDGER_FILE_EXTENSION);
+  return end === -1 ? void 0 : name.slice(0, end + LEDGER_FILE_EXTENSION.length);
+}
+function legacy_directory_names(directory) {
+  try {
+    const names = readdirSync(directory).map((name) => source_name(name));
+    return [...new Set(names.filter((name) => name !== void 0))];
+  } catch {
+    return [];
+  }
+}
+function migrate_directory(root) {
+  const legacy_directory = path.join(root, LEGACY_OBSERVATION_LEDGER_DIRECTORY);
+  const did_move = legacy_directory_names(legacy_directory).map(
+    (name) => migrate_one(
+      path.join(legacy_directory, name),
+      path.join(root, OBSERVATION_LEDGER_DIRECTORY, name)
+    )
+  ).some(Boolean);
+  try {
+    rmdirSync(legacy_directory);
+  } catch {
+  }
+  return did_move;
+}
+function migrate(root) {
+  const target = path.join(root, OBSERVATION_LEDGER_DIRECTORY, LEGACY_LEDGER_FILE);
+  const moved_files = LEGACY_OBSERVATION_LEDGER_PATHS.map(
+    (legacy) => migrate_one(path.join(root, legacy), target)
+  );
+  return [...moved_files, migrate_directory(root)].some(Boolean);
+}
+var observation_ledger_migrate = { migrate };
+
+// scripts/observations/observation-ledger-home.ts
+var DATE_END = 10;
+function ledger_root(cwd = process.cwd()) {
+  return cwd;
+}
+function ledger_directory(cwd = process.cwd()) {
+  const root = ledger_root(cwd);
+  observation_ledger_migrate.migrate(root);
+  return path2.join(root, OBSERVATION_LEDGER_DIRECTORY);
+}
+function file_path(name, cwd) {
+  ledger_directory(cwd);
+  return path2.join(ledger_root(cwd), observation_ledger.ledger_file(name));
+}
+function issue_path(issue, cwd = process.cwd()) {
+  return file_path(issue, cwd);
+}
+async function current_branch(cwd) {
+  try {
+    return await git_spawn.read(["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+  } catch {
+    return "";
+  }
+}
+function ledger_date(now) {
+  return now.toISOString().slice(0, DATE_END);
+}
+async function writer_path(now, cwd = process.cwd()) {
+  const issue = git_branch.issue_from_branch(await current_branch(cwd));
+  return file_path(issue ?? ledger_date(now), cwd);
+}
+async function read_file(target, is_strict) {
+  try {
+    const content = await readFile(target, "utf8");
+    return content.length === 0 || content.endsWith("\n") ? content : `${content}
+`;
+  } catch (error) {
+    if (is_strict) throw error;
+    return "";
+  }
+}
+async function ledger_files(directory, is_strict) {
+  try {
+    const names = await readdir(directory);
+    return names.filter((name) => observation_ledger.is_ledger_file_name(name)).toSorted((left, right) => left.localeCompare(right));
+  } catch (error) {
+    if (is_strict) throw error;
+    return void 0;
+  }
+}
+async function read(cwd = process.cwd(), is_strict = false) {
+  const directory = ledger_directory(cwd);
+  const files = await ledger_files(directory, is_strict);
+  if (files === void 0) return void 0;
+  const contents = await Promise.all(
+    files.map(async (name) => await read_file(path2.join(directory, name), is_strict))
+  );
+  return contents.join("");
+}
+async function append(target, lines) {
+  if (lines.length === 0) return;
+  await mkdir(path2.dirname(target), { recursive: true });
+  await appendFile(target, `${lines.join("\n")}
+`, "utf8");
+}
+var observation_ledger_home = {
+  append,
+  file_path,
+  issue_path,
+  ledger_date,
+  ledger_root,
+  read,
+  read_file,
+  writer_path
+};
+
+export {
+  observation_ledger_line,
+  observation_ledger_home
+};

package/dist/commands/chunk-N5YPDLZM.js

@@ -0,0 +1,114 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  BREAKING_CHANGE_LABEL,
+  DEFERRED_LABEL,
+  EPIC_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
+  RELEASE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/issue/issue-auto-ok.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var JUDGEMENT_NOT_NEEDED = issue_body_keys.line("judgement", "not_needed");
+var JUDGEMENT_NEEDED = issue_body_keys.line("judgement", "needed");
+var DECLARATION_PROBLEM = `declare under \`${BACKGROUND_HEADING}\` whether a person's judgement (a policy decision, an external account, a human visual check) is needed: \`${JUDGEMENT_NOT_NEEDED}\` or \`${JUDGEMENT_NEEDED}\uFF08<which one>\uFF09\` \u2014 exactly one (\`issue-template.md\`)`;
+var DECISION_RULE_PREFIX = issue_body_keys.prefix("decision_rule");
+var DECISION_PROBLEM = `a decision rule citing a measurement Issue determines the choice; declare \`${JUDGEMENT_NOT_NEEDED}\` and record the applied result and reason in an Issue comment`;
+var OPTED_OUT = { is_applied: false, reason: "--no-auto-ok declared" };
+var CROSS_REPOSITORY = {
+  is_applied: false,
+  reason: "the Issue is filed to another repository"
+};
+var JUDGEMENT = {
+  is_applied: false,
+  reason: `the body declares \`${JUDGEMENT_NEEDED}\``
+};
+var APPLIED = {
+  is_applied: true,
+  reason: "no exclusion holds and the body declares no judgement is needed"
+};
+var CONSTRAINT_HEADING = issue_body_keys.heading("auto_execution_constraint");
+var CONSTRAINT_SOURCE = `${issue_body_keys.prefix("constraint_source")} user`;
+var CONSTRAINT_REFERENCE = `${issue_body_keys.prefix("constraint_reference")} `;
+var CONSTRAINT_INSTRUCTION = `${issue_body_keys.prefix("constraint_instruction")} `;
+var CONSTRAINT_FIELDS = [CONSTRAINT_REFERENCE, CONSTRAINT_INSTRUCTION];
+var CONSTRAINT_PROBLEM = `--no-auto-ok without an exclusion needs ${CONSTRAINT_HEADING}: ${CONSTRAINT_SOURCE}, ${CONSTRAINT_REFERENCE}<original user prompt or comment URL>, ${CONSTRAINT_INSTRUCTION}<verbatim prohibition>; verify the cited user instruction, not an agent inference or a later judgement. Kickoff ending at planning is not an opt-out.`;
+var USER_CONSTRAINT = {
+  is_applied: false,
+  reason: "a user prohibition is recorded under \u81EA\u52D5\u5B9F\u884C\u306E\u5236\u7D04"
+};
+function user_constraint_of(body) {
+  const section = markdown_section.section_lines(body, CONSTRAINT_HEADING).join("\n");
+  const lines = markdown_section.unfenced_lines(section).map((line) => line.trim());
+  const has_fields = CONSTRAINT_FIELDS.every(
+    (prefix) => lines.some((line) => line.startsWith(prefix) && line.slice(prefix.length).trim() !== "")
+  );
+  return has_fields && lines.includes(CONSTRAINT_SOURCE) ? USER_CONSTRAINT : void 0;
+}
+var EXCLUDED_LABELS = [
+  [RELEASE_LABEL, "a release is Tier C"],
+  [BREAKING_CHANGE_LABEL, "a breaking change needs a person to accept the migration"],
+  [DEFERRED_LABEL, "the Issue is deferred"],
+  [NEEDS_HUMAN_REVIEW_LABEL, "a person reviews the change before it lands"],
+  [EPIC_LABEL, "an epic is opted in by a person, and that opts in every descendant"]
+];
+function exclusion_of(labels) {
+  const found = EXCLUDED_LABELS.find(([label]) => has_label_name(labels, label));
+  if (found === void 0) return void 0;
+  return { is_applied: false, reason: `a \`${found[0]}\` Issue \u2014 ${found[1]}` };
+}
+function background_lines(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  return markdown_section.unfenced_lines(background).map((line) => line.trim());
+}
+function judgement_of(body) {
+  const lines = background_lines(body);
+  const is_not_needed = lines.some((line) => line.startsWith(JUDGEMENT_NOT_NEEDED));
+  const is_needed = lines.some((line) => line.startsWith(JUDGEMENT_NEEDED));
+  return is_not_needed === is_needed ? void 0 : is_needed;
+}
+function declaration_problem(body) {
+  return judgement_of(body) === void 0 ? DECLARATION_PROBLEM : void 0;
+}
+function decision_problem(body) {
+  if (judgement_of(body) !== true) return void 0;
+  const has_rule = background_lines(body).some(
+    (line) => line.startsWith(DECISION_RULE_PREFIX) && /#[1-9]\d*\b/u.test(line)
+  );
+  return has_rule ? DECISION_PROBLEM : void 0;
+}
+function body_decision(body) {
+  return user_constraint_of(body) ?? (judgement_of(body) === false ? APPLIED : JUDGEMENT);
+}
+function decide(filing) {
+  if (filing.is_opted_out) return OPTED_OUT;
+  if (filing.is_cross_repository) return CROSS_REPOSITORY;
+  return exclusion_of(filing.labels) ?? body_decision(filing.body);
+}
+function opt_out_problem(filing) {
+  if (!filing.is_opted_out || user_constraint_of(filing.body) !== void 0) return void 0;
+  const without_opt_out = decide({ ...filing, is_opted_out: false });
+  return without_opt_out.is_applied ? CONSTRAINT_PROBLEM : void 0;
+}
+function line_of(decision) {
+  return `auto-ok: ${decision.is_applied ? "applied" : "not applied"} \u2014 ${decision.reason}`;
+}
+var issue_auto_ok = {
+  declaration_problem,
+  decide,
+  decision_problem,
+  exclusion_of,
+  line_of,
+  opt_out_problem,
+  user_constraint_of
+};
+
+export {
+  issue_auto_ok
+};

package/dist/commands/chunk-NASUAXRJ.js

@@ -0,0 +1,45 @@
+import {
+  review_comment_round
+} from "./chunk-5SOU366I.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/review/review-record.ts
+async function has_comment_record(issue, read) {
+  try {
+    const lines = await read(issue);
+    return review_finding_ledger.has_issue_record(lines.join("\n"), issue);
+  } catch {
+    return false;
+  }
+}
+async function is_recorded(content, issue, read) {
+  if (review_finding_ledger.has_issue_record(content, issue)) return true;
+  return await has_comment_record(issue, read);
+}
+async function check(issue, root = observation_ledger_home.ledger_root(), read_comment_lines = review_comment_round.issue_lines) {
+  const content = await observation_ledger_home.read(root);
+  if (content === void 0) return { status: "not-required" };
+  if (await is_recorded(content, issue, read_comment_lines)) return { status: "ok", issue };
+  return { status: "missing", issue };
+}
+var MISSING_REASON = "No review round is recorded for this issue, so there is no evidence `/code-review` ran. A round whose findings are never recorded leaves the recurrence ledger blind, which is indistinguishable from a round nobody reviewed \u2014 so an unrecorded round is refused (joshuafolkken/kit#2343).";
+var REMEDY = "Record the round with `pnpm josh review:record --issue <N> [<category>:<severity>:<file> ...]` \u2014 a clean round is a call with no findings, which records one zero-finding line \u2014 then reissue the merge.";
+function refusal_message(issue) {
+  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
+}
+var review_record = {
+  check,
+  refusal_message
+};
+
+export {
+  review_record
+};