@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-OSBWXZJ4.js

@@ -1,492 +0,0 @@
-import {
-  review_size
-} from "./chunk-56KW5EOK.js";
-import {
-  lane_session_broker
-} from "./chunk-L7DAL54N.js";
-import {
-  run_ship_review
-} from "./chunk-MRORPFSO.js";
-import {
-  issue_declared_size
-} from "./chunk-EZ7IPKIH.js";
-import {
-  split_measure
-} from "./chunk-MI2OS6TL.js";
-import {
-  removed_tests_check
-} from "./chunk-47UZB54M.js";
-import {
-  review_reviewed_tree
-} from "./chunk-GITT5A5A.js";
-import {
-  review_comment_round
-} from "./chunk-CKUKK7JG.js";
-import {
-  issue_watch_gate
-} from "./chunk-OVWPZDWP.js";
-import {
-  test_related_verdict
-} from "./chunk-XUMYPESL.js";
-import {
-  review_brief,
-  review_fix_round,
-  review_round
-} from "./chunk-EKLU6QR7.js";
-import {
-  review_round_one_blobs
-} from "./chunk-BMKWSWWE.js";
-import {
-  review_untouched_readers
-} from "./chunk-WMMGXJXP.js";
-import {
-  review_interaction
-} from "./chunk-TJKM56WJ.js";
-import {
-  review_level
-} from "./chunk-RVUJ6F5L.js";
-import {
-  review_diff_parts
-} from "./chunk-MY3RSOS5.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  path_decision
-} from "./chunk-QHWJJ6X5.js";
-import {
-  review_code_tree
-} from "./chunk-KK2SL42W.js";
-import {
-  review_attest,
-  review_checkout
-} from "./chunk-KIILCKQR.js";
-import {
-  observation_ledger_home
-} from "./chunk-WWVYEHQT.js";
-import {
-  bash_output_cap_reader
-} from "./chunk-JFLFGLE4.js";
-import {
-  scoped_green
-} from "./chunk-WTH6NTXU.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  review_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  agent_session_role
-} from "./chunk-U3IVVR4W.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  REVIEW_GATE_SCHEMA,
-  package_manifest
-} from "./chunk-WB4T3VY2.js";
-
-// scripts/review/review-brief-cli.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
-
-// scripts/review/review-diff-write.ts
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
-// scripts/review/review-diff-pack.ts
-function fits(bundle, part, cap) {
-  return bundle !== void 0 && bundle.text.length + part.length <= cap;
-}
-function add(bundles, relative, part, cap) {
-  const last = bundles.at(-1);
-  if (!fits(last, part, cap)) {
-    bundles.push({ text: part, paths: [relative] });
-    return;
-  }
-  last.text += part;
-  if (last.paths.at(-1) !== relative) last.paths.push(relative);
-}
-function pack(entries, cap) {
-  const bundles = [];
-  for (const entry of entries) {
-    for (const part of entry.parts) add(bundles, entry.relative, part, cap);
-  }
-  return bundles;
-}
-function parts_of(written) {
-  const parts = {};
-  for (const { file, paths } of written) {
-    for (const relative of paths) parts[relative] = [...parts[relative] ?? [], file];
-  }
-  return parts;
-}
-var review_diff_pack = { pack, parts_of };
-
-// scripts/review/review-diff-write.ts
-var DIRECTORY_PREFIX = "josh-review-diff-";
-var DIRECTORY_MODE = 448;
-var FILE_MODE = 384;
-var PART_SUFFIX = ".diff";
-var INDEX_WIDTH = 3;
-var NUL = "\0";
-var SLUG_SEPARATOR = "__";
-function untracked_text(root, relative) {
-  try {
-    const content = readFileSync(path.join(root, relative), "utf8");
-    if (content.includes(NUL)) return `untracked binary file ${relative}, not shown
-`;
-    return `untracked file ${relative}, shown whole:
-${content}`;
-  } catch {
-    return `${relative} is listed by the change but holds no diff and no file
-`;
-  }
-}
-async function path_diff(root, base, relative) {
-  const diff = await git_spawn.read(["-C", root, "diff", "--no-color", base, "--", relative]);
-  return diff.length > 0 ? diff : untracked_text(root, relative);
-}
-function part_name(position, bundle) {
-  const prefix = String(position).padStart(INDEX_WIDTH, "0");
-  const [first = ""] = bundle.paths;
-  return `${prefix}-${first.split("/").join(SLUG_SEPARATOR)}${PART_SUFFIX}`;
-}
-function write_bundle(directory, bundle, position) {
-  const file = path.join(directory, part_name(position, bundle));
-  writeFileSync(file, bundle.text, { flag: "wx", mode: FILE_MODE });
-  return file;
-}
-function fresh_directory(root) {
-  const directory = stamp_file.stamp_path(DIRECTORY_PREFIX, root, "");
-  rmSync(directory, { recursive: true, force: true });
-  mkdirSync(directory, { mode: DIRECTORY_MODE });
-  return directory;
-}
-async function write_parts(request, directory) {
-  const { root, base, paths, cap } = request;
-  const texts = await Promise.all(
-    paths.map(async (relative) => ({ relative, text: await path_diff(root, base, relative) }))
-  );
-  const target = directory ?? fresh_directory(root);
-  const entries = texts.map(({ relative, text }) => ({
-    relative,
-    parts: review_diff_parts.part_texts(relative, text, cap)
-  }));
-  const bundles = review_diff_pack.pack(entries, cap);
-  return review_diff_pack.parts_of(
-    bundles.map((bundle, position) => ({
-      file: write_bundle(target, bundle, position),
-      paths: bundle.paths
-    }))
-  );
-}
-var review_diff_write = { path_diff, write_parts };
-
-// scripts/review/review-gate-mode.ts
-var ENV_KEY = "JOSH_REVIEW_GATE";
-var DEFAULT_MODE = "local";
-function read(directory = process.cwd()) {
-  return REVIEW_GATE_SCHEMA.safeParse(process.env[ENV_KEY]).data ?? package_manifest.read_nearest_value(
-    directory,
-    package_manifest.josh_schemas.review_gate,
-    function select_mode(manifest) {
-      return manifest.josh?.review_gate;
-    }
-  ) ?? DEFAULT_MODE;
-}
-var review_gate_mode = { read };
-
-// scripts/review/review-round-one-skip.ts
-var NOTE = "round1: skipped-in-size";
-var BLOCKING = /* @__PURE__ */ new Set(["high", "medium"]);
-var KINDS = ["code", "interaction"];
-async function is_in_size(issue) {
-  const declared = await issue_declared_size.read(String(issue));
-  if (declared === void 0 || Math.min(declared.files, declared.lines) <= 0) return false;
-  const actual = await split_measure.read_branch();
-  return actual.files <= declared.files && actual.lines <= declared.lines;
-}
-async function is_eligible(issue) {
-  if (!await is_in_size(issue)) return false;
-  const content = await observation_ledger_home.read(void 0, true);
-  if (content === void 0) return false;
-  const comments = await review_comment_round.issue_lines(issue);
-  const history = [content, ...comments].join("\n");
-  return KINDS.every(
-    (kind) => review_finding_ledger.issue_dispositions(history, issue, kind).every((line) => !BLOCKING.has(line.severity))
-  );
-}
-async function eligible_issue() {
-  if (review_gate_mode.read() !== "local") return void 0;
-  try {
-    const issue = git_branch.issue_from_branch(await git_command.branch());
-    return issue !== void 0 && await is_eligible(issue) ? issue : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function record(issue) {
-  await lane_ledger_write.record_round_one({ issue, verdict: "skipped" });
-  process.stderr.write(`${NOTE}
-`);
-}
-async function run(issue, review) {
-  const is_skipped = issue !== void 0;
-  const result = await review(is_skipped ? review_round.SECOND_ROUND : 1, is_skipped);
-  if (result === 0 && issue !== void 0) await record(issue);
-  return result;
-}
-var review_round_one_skip = { eligible_issue, record, run, NOTE };
-
-// scripts/review/review-brief-cli.ts
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/review/review-brief-cli.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var USAGE = "Usage: josh review:brief [--round <1|2> | --full-change] | --interaction | --level-only [--staged] [--json]";
-var MODULE_DIRECTORY = path2.dirname(fileURLToPath(__josh_source_url));
-var RUBRIC_PATH = path2.join(
-  find_package_directory(MODULE_DIRECTORY),
-  review_brief.RUBRIC_RELATIVE_PATH
-);
-var LEVEL_ONLY_FLAG = "--level-only";
-var INTERACTION_FLAG = "--interaction";
-var LEVEL_KEY = "level";
-var FIRST_ROUND = 1;
-var FAILURE_EXIT_CODE = 1;
-var KEPT_NOTE_PREFIX = "Round-1 snapshot: kept the record taken at";
-function kept_note(taken_at) {
-  return `${KEPT_NOTE_PREFIX} ${taken_at} rather than retaking it \u2014 the fix delta is measured from there, so everything changed since is reviewed rather than assumed away. Check that timestamp: a record left behind by an earlier run measures the delta from further back, which widens the round rather than narrowing it (joshuafolkken/kit#1441).`;
-}
-function record_round_one(round, tree, base, target) {
-  if (round !== FIRST_ROUND) return false;
-  try {
-    const recorded = review_stamps.round_one_stamp.read(target);
-    if (recorded !== void 0) {
-      console.error(kept_note(recorded.taken_at));
-      return false;
-    }
-    const blobs = review_round_one_blobs.capture(Object.keys(tree));
-    review_stamps.round_one_stamp.write(tree, target, base, blobs);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function findings_tree(checkout) {
-  const { findings } = lane_session_broker.review_paths(PROJECT_ROOT);
-  const briefed = review_stamps.briefed_stamp.read();
-  if (briefed === void 0 || !review_attest.is_briefed_since(briefed.taken_at, checkout.root)) {
-    return void 0;
-  }
-  const is_clean = review_attest.is_reviewed_on(checkout, findings, checkout.root) && run_ship_review.is_clean_round_one(stamp_file.read_stamp_text(findings));
-  return is_clean ? briefed : void 0;
-}
-function attested_tree(checkout) {
-  return review_reviewed_tree.resume_point(checkout) ?? findings_tree(checkout);
-}
-function slot_of(interaction) {
-  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
-  return interaction === void 0 ? CODE : INTERACTION;
-}
-async function open_contract(slot) {
-  const checkout = await review_checkout.read_checkout();
-  const is_code = slot === review_attest.REVIEW_SLOT.CODE;
-  const resumed_from = is_code ? attested_tree(checkout) : void 0;
-  const fix_round = is_code ? review_fix_round.resume(checkout) : void 0;
-  const nonce = review_attest.record_target(checkout, checkout.root, slot);
-  return { checkout, nonce, resumed_from, fix_round };
-}
-function record_briefed(tree, base) {
-  try {
-    const blobs = review_round_one_blobs.capture(Object.keys(tree));
-    review_stamps.briefed_stamp.write(tree, void 0, base, blobs);
-  } catch {
-  }
-}
-async function read_diff(root, base, paths) {
-  const cap = bash_output_cap_reader.bash_output_cap(root);
-  try {
-    return { parts: await review_diff_write.write_parts({ root, base, paths, cap }), cap };
-  } catch {
-    return void 0;
-  }
-}
-async function read_removed_tests() {
-  try {
-    return await removed_tests_check.read() ?? [];
-  } catch {
-    return [];
-  }
-}
-async function read_readers(root, base, paths) {
-  try {
-    return await review_untouched_readers.read({ root, base, paths });
-  } catch {
-    return review_untouched_readers.FAILED_READ;
-  }
-}
-async function compose_brief(request) {
-  const { round, paths, tree, base, profile, interaction } = request;
-  const contract = await open_contract(slot_of(interaction));
-  const stamps = {
-    gate: review_stamps.gate_stamp.read(),
-    in_flight: review_stamps.in_flight_stamp.read(),
-    round_one: review_stamps.round_one_stamp.read()
-  };
-  return review_brief.compose({
-    is_full_change: request.is_full_change,
-    level: request.level,
-    profile,
-    round,
-    tree,
-    stamps,
-    // Resolved by the caller rather than printed as a `$(…)` the forked agent would expand: a
-    // subshell that fails expands to nothing, and the bare `git diff` left behind lists only the
-    // unstaged working tree — a review silently narrowed to a fraction of the change.
-    // One reading is shared with the record written below, so the commit
-    // the map is stored against is the same one the brief printed.
-    base,
-    rubric_path: RUBRIC_PATH,
-    ...contract,
-    diff: await read_diff(contract.checkout.root, base, paths),
-    readers: await read_readers(contract.checkout.root, base, paths),
-    removed_tests: await read_removed_tests(),
-    interaction,
-    high_cited: review_reviewed_tree.high_cited()
-  });
-}
-async function read_bases() {
-  const commit = await change_base.resolved_through_merge();
-  return { base: commit ?? await git_command.change_base(), commit };
-}
-function report_error(message) {
-  console.error(message);
-  return FAILURE_EXIT_CODE;
-}
-async function run_level(argv) {
-  return await path_decision.run_path_decision(argv, {
-    usage: USAGE,
-    key: LEVEL_KEY,
-    decide: async (paths, is_staged) => {
-      const lines = await review_size.read(paths, is_staged);
-      return review_level.level_for(paths, lines);
-    },
-    explain: review_level.format_reason
-  });
-}
-function refusal_for_round(reading, round) {
-  const { tree, commit } = reading;
-  const refusal = scoped_green.refusal_for(tree, commit);
-  if (refusal === void 0 || round === FIRST_ROUND) return refusal;
-  return scoped_green.refusal_for(tree, commit, { test: test_related_verdict.touched_target() });
-}
-async function read_change() {
-  const { base, commit } = await read_bases();
-  const paths = await changed_paths.read_changed_paths(false);
-  const tree = await review_tree.read_changed_tree(paths);
-  const lines = await review_size.read(paths);
-  return { base, commit, paths, tree, level: review_level.level_for(paths, lines) };
-}
-async function record_review(round, tree, commit) {
-  const is_snapshot_written = record_round_one(round, tree, commit);
-  if (is_snapshot_written) await review_code_tree.record(Object.keys(tree), commit);
-  record_briefed(tree, commit);
-  review_round.record(round);
-}
-async function run_review(round, reading, emit, options = {}) {
-  const { commit, tree, level } = reading;
-  const refusal = refusal_for_round(reading, round);
-  if (refusal !== void 0) return report_error(refusal);
-  const resolved = agent_role_profile.resolve_review(round, process.env, level === "low");
-  if (resolved.kind === "rejected") return report_error(resolved.note);
-  agent_role_profile.warn_of_default();
-  emit(await compose_brief({ ...reading, round, profile: resolved.profile, ...options }));
-  if (options.interaction === void 0) await record_review(round, tree, commit);
-  return 0;
-}
-async function run_interaction(emit) {
-  const reading = await read_change();
-  const targets = review_interaction.due_paths(reading.paths);
-  if (targets.length === 0) {
-    emit(review_interaction.NOT_DUE_LINE);
-    return 0;
-  }
-  const stale = await issue_watch_gate.review_refusal_here();
-  if (stale !== void 0) return report_error(stale);
-  return await run_review(FIRST_ROUND, reading, emit, { interaction: targets });
-}
-async function scoped_refusal() {
-  const { tree, commit } = await read_change();
-  return scoped_green.refusal_for(tree, commit);
-}
-var REVIEWER_REFUSAL = "review:brief refused: this is a reviewer session (JOSH_AGENT_ROLE=reviewer). A new brief would drop the attestation this review already left \u2014 review the brief you were handed and report.";
-async function run_brief(argv, emit) {
-  if (argv.length === 0) {
-    return await review_round_one_skip.run(
-      await review_round_one_skip.eligible_issue(),
-      async (round2, is_full_change2) => await run_review(round2, await read_change(), emit, { is_full_change: is_full_change2 })
-    );
-  }
-  if (argv.length === 1 && argv[0] === INTERACTION_FLAG) return await run_interaction(emit);
-  const round = review_round.parse_round(argv);
-  if (round === void 0) return report_error(USAGE);
-  const is_full_change = argv.includes(review_round.FULL_CHANGE_FLAG);
-  return await run_review(round, await read_change(), emit, { is_full_change });
-}
-async function run_to(argv, emit) {
-  if (argv[0] === LEVEL_ONLY_FLAG) return await run_level(argv.slice(1));
-  if (agent_session_role.is_reviewer()) return report_error(REVIEWER_REFUSAL);
-  return await run_brief(argv, emit);
-}
-async function run2(argv) {
-  return await run_to(argv, console.info);
-}
-var review_brief_cli = {
-  attested_tree,
-  FIRST_ROUND,
-  format_reason: review_level.format_reason,
-  KEPT_NOTE_PREFIX,
-  parse_round: review_round.parse_round,
-  record_review,
-  record_round_one,
-  report_error,
-  run: run2,
-  run_to,
-  scoped_refusal
-};
-
-export {
-  review_brief_cli
-};

package/dist/commands/chunk-OT3UMEWK.js

@@ -1,47 +0,0 @@
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/lines/line-targets.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-var LINT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".svelte"
-]);
-var WHOLE_TREE_PATHSPEC = ":/";
-var LS_FILES_FLAGS = [
-  "ls-files",
-  "--cached",
-  "--others",
-  "--exclude-standard",
-  "--full-name",
-  "-z"
-];
-var NUL = "\0";
-function is_lint_target(relative_path) {
-  return LINT_EXTENSIONS.has(path.extname(relative_path));
-}
-function split_names(output) {
-  return output.split(NUL).filter((name) => name.length > 0);
-}
-async function lint_target_files(root) {
-  const output = await git_spawn.read([...LS_FILES_FLAGS, WHOLE_TREE_PATHSPEC]);
-  return split_names(output).filter((name) => is_lint_target(name)).map((name) => path.resolve(root, name)).filter((file_path) => existsSync(file_path));
-}
-var line_targets = {
-  is_lint_target,
-  lint_target_files,
-  split_names
-};
-
-export {
-  line_targets
-};

package/dist/commands/chunk-OVWPZDWP.js

@@ -1,64 +0,0 @@
-import {
-  issue_watch
-} from "./chunk-J7IO3AYH.js";
-import {
-  review_attest
-} from "./chunk-KIILCKQR.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/issue/issue-watch-gate.ts
-var EVERY_CALL_MS = 0;
-function ack_command(issue) {
-  return `pnpm josh issue:ack ${issue}`;
-}
-function unread_message(record) {
-  return [
-    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
-    record.pending ?? "",
-    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
-  ].join("\n\n");
-}
-function review_message(record, briefed_at) {
-  return [
-    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
-    "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
-  ].join("\n");
-}
-async function polled(root) {
-  return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
-}
-async function unread_refusal(root) {
-  const record = await polled(root);
-  return record?.pending === void 0 ? void 0 : unread_message(record);
-}
-async function review_refusal(root) {
-  const record = await polled(root);
-  if (record === void 0) return void 0;
-  if (record.pending !== void 0) return unread_message(record);
-  const pointer = review_attest.read_pointer(root);
-  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
-  return review_message(record, pointer.taken_at);
-}
-async function review_refusal_here() {
-  return await review_refusal(await git_command.repository_root());
-}
-async function assert_read_here() {
-  const refusal = await unread_refusal(await git_command.repository_root());
-  if (refusal !== void 0) throw new Error(refusal);
-}
-var issue_watch_gate = {
-  assert_read_here,
-  review_refusal,
-  review_refusal_here,
-  unread_message,
-  unread_refusal
-};
-
-export {
-  issue_watch_gate
-};