@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-ZEH2B3DF.js

@@ -0,0 +1,239 @@
+import {
+  run_cut_decline
+} from "./chunk-NFKWFOFM.js";
+import {
+  run_cut_ready
+} from "./chunk-2ONSHOAY.js";
+import {
+  cost_cli,
+  cost_verdict
+} from "./chunk-JEYITIWB.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-TFDVTU6O.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/implementation-cut.ts
+import path from "node:path";
+
+// scripts/rules/edit-tool.ts
+var EDIT = "Edit";
+var WRITE = "Write";
+var EDIT_TOOLS = /* @__PURE__ */ new Set([EDIT, WRITE]);
+function is_edit_tool(name) {
+  return EDIT_TOOLS.has(name);
+}
+function string_field(input, key) {
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+var edit_tool = {
+  EDIT,
+  WRITE,
+  is_edit_tool,
+  string_field
+};
+
+// scripts/rules/implementation-cut-verdict.ts
+import { z } from "zod";
+var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
+var VERDICT_REUSE_MS = 5e3;
+var VERDICT_VALUES = [
+  "over",
+  "under",
+  "unmeasurable"
+];
+var cache_schema = z.object({ read_at_ms: z.number(), verdict: z.enum(VERDICT_VALUES) });
+function cache_path(directory) {
+  return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
+}
+function cached_verdict(target, now_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  const cached = json_value.parse_with(raw, cache_schema);
+  if (cached === void 0) return void 0;
+  return now_ms - cached.read_at_ms < VERDICT_REUSE_MS ? cached.verdict : void 0;
+}
+function reused_verdict(read, directory, now_ms = Date.now()) {
+  const target = cache_path(directory);
+  const cached = cached_verdict(target, now_ms);
+  if (cached !== void 0) return cached;
+  const value = read();
+  stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
+  return value;
+}
+var implementation_cut_verdict = {
+  VERDICT_REUSE_MS,
+  cache_path,
+  reused_verdict
+};
+
+// scripts/rules/implementation-cut.ts
+var { is_edit_tool: is_edit_tool2 } = edit_tool;
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var IMPL_FLAG = /(?:^|\s)--impl(?:[=\s]|$)/u;
+var RESUME_FLAG = /(?:^|\s)--resume(?:[=\s]|$)/u;
+function calls_cut_with(command, flag) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, CUT_COMMANDS) && flag.test(segment));
+}
+function takes_the_impl_cut(command) {
+  return calls_cut_with(command, IMPL_FLAG);
+}
+function resumes_a_cut(command) {
+  return calls_cut_with(command, RESUME_FLAG);
+}
+function can_cut_sync(issue, cwd) {
+  const directory = run_cut.worktree_git_directory_sync(cwd);
+  if (run_cut_decline.is_declined_sync(issue, directory)) return false;
+  return run_cut_ready.is_ready_sync(() => run_cut_ready.read_tree_sync(cwd));
+}
+function is_named(value) {
+  return value !== void 0 && value !== "";
+}
+function environment_for(transcript, source) {
+  if (agent_provider.resolve_provider(source).kind === "rejected" || is_named(source[agent_provider.CODEX_SESSION_KEY]) || is_named(source[agent_session_environment.SESSION_ID_KEY])) {
+    return source;
+  }
+  return {
+    ...source,
+    [agent_session_environment.SESSION_ID_KEY]: path.basename(transcript, ".jsonl")
+  };
+}
+function session_verdict(transcript, directory, source) {
+  return implementation_cut_verdict.reused_verdict(
+    () => cost_cli.session_verdict(directory, environment_for(transcript, source)),
+    transcript
+  );
+}
+function current_state(context, transcript) {
+  const { cwd, env } = context;
+  return {
+    directory: cwd,
+    source: env,
+    // The cut record and the run hold of the call's own work tree.
+    carried: (now) => run_cut.carried_cut_sync(now, run_cut.worktree_git_directory_sync(cwd)),
+    held_issue: () => run_cut.held_issue_sync(run_cut.worktree_git_directory_sync(cwd)),
+    // **Read through the short reuse window**. The row now fires per
+    // threshold crossing rather than once per run, so this predicate is a candidate on every edit;
+    // the window collapses one turn's burst of edits to a single whole-transcript price.
+    verdict: () => transcript === void 0 ? implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict(cwd, env), cwd) : session_verdict(transcript, cwd, env),
+    can_cut: (issue) => can_cut_sync(issue, cwd)
+  };
+}
+function lane_child_issue(state) {
+  if (!lane_child_marker.is_child_of(state.directory, state.source)) return void 0;
+  return lane_paths.lane_issue_of(state.directory, { ...state.source });
+}
+function held_run_issue(state) {
+  if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== void 0) return void 0;
+  return state.held_issue();
+}
+function implementing_run_issue(state) {
+  if (agent_session_role.is_reviewer(state.source)) return void 0;
+  return lane_child_issue(state) ?? held_run_issue(state);
+}
+function uncut_run_issue(state) {
+  const issue = implementing_run_issue(state);
+  if (issue === void 0) return void 0;
+  return state.carried()?.issue === issue ? void 0 : issue;
+}
+function file_path_of(call) {
+  if (!json_value.is_record(call.input)) return "";
+  const value = call.input["file_path"];
+  return typeof value === "string" ? value : "";
+}
+function is_handoff_write(call, directory, issue) {
+  const handoff = path.resolve(directory, run_cut_handoff.handoff_path_of(issue));
+  return path.resolve(directory, file_path_of(call)) === handoff;
+}
+function refusable_issue(call, state) {
+  const issue = uncut_run_issue(state);
+  if (issue === void 0) return void 0;
+  return is_handoff_write(call, state.directory, issue) ? void 0 : issue;
+}
+function warrants_the_cut(state) {
+  return state.verdict() === cost_verdict.OVER_VERDICT;
+}
+function is_over_threshold_edit(call, state) {
+  if (!is_edit_tool2(call.name)) return false;
+  const issue = refusable_issue(call, state);
+  if (issue === void 0) return false;
+  return warrants_the_cut(state) && state.can_cut(issue);
+}
+var THRESHOLD_TEXT = "`pnpm josh cost --cut`";
+var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: refused on every edit over ${THRESHOLD_TEXT}. Write \`${run_cut_handoff.HANDOFF_PATH}\`: ${run_cut_handoff.HANDOFF_FORMAT}, run \`pnpm josh run:cut --impl <N> --handoff <path>\`; \`cut\`: end the turn immediately, no Telegram is owed; else reissue the edit (\`.claude/skills/workflow-commands/pre-gate-cut.md\`).`;
+var REISSUE_WINDOW_MS = 9e4;
+function is_reissued_refusal(now_ms, delivered_at_ms) {
+  return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
+}
+function decide(_call, run, _can_record, delivered_at_ms) {
+  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
+}
+function decide_for_session(call, run, can_record, delivered_at_ms) {
+  return decide(call, run, can_record, delivered_at_ms) && is_over_threshold_edit(call, current_state(run.context, run.transcript));
+}
+function is_refusable_edit(call, state) {
+  return is_edit_tool2(call.name) && refusable_issue(call, state) !== void 0;
+}
+function is_refusable_edit_in(call, context) {
+  return is_refusable_edit(call, current_state(context));
+}
+var ROW = {
+  id: "implementation-cut",
+  is_trigger: is_refusable_edit_in,
+  reason: IMPLEMENTATION_CUT_REASON,
+  decide: decide_for_session,
+  // The opening the reason carried before it was cut to the action and the next command.
+  former_reasons: [
+    "\u26D4 implementation-phase cut: this checkout is a lane dispatched",
+    "\u26D4 implementation-phase cut: this run's context crossed the"
+  ],
+  about: {
+    title: "The implementation-phase cut",
+    topic: '`.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "It is a guard, fired at the edit that crosses the threshold"',
+    fires: "an `Edit` / `Write` by an uncut lane child whose recent context is over the `pnpm josh cost --cut` threshold; it hands over `pnpm josh run:cut --impl <N> --handoff <path>`. At each threshold crossing",
+    quiet: "not a lane child, a non-editing tool, the run's own handoff file, already cut, or under the threshold"
+  }
+};
+var implementation_cut = {
+  IMPLEMENTATION_CUT_REASON,
+  REISSUE_WINDOW_MS,
+  ROW,
+  decide,
+  is_over_threshold_edit,
+  is_reissued_refusal,
+  resumes_a_cut,
+  session_verdict,
+  takes_the_impl_cut,
+  uncut_run_issue
+};
+
+export {
+  edit_tool,
+  implementation_cut_verdict,
+  implementation_cut
+};

package/dist/commands/chunk-ZEUKX3RZ.js

@@ -0,0 +1,245 @@
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  since_green
+} from "./chunk-4K7KLR7L.js";
+import {
+  test_read_map
+} from "./chunk-B2PJEV3S.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/test/pure-files-entries.ts
+import path from "node:path";
+var PURE_FILES_PATH = path.join("tools", "test", "pure-files.ts");
+var LIST_TESTS = [
+  path.join("tools", "test", "pure-files.test.ts"),
+  path.join("tools", "test", "classify-isolation.test.ts")
+];
+var ENTRY_LINE = /^\t'(?<entry>[^']+)',$/u;
+function entry_of(line) {
+  return ENTRY_LINE.exec(line)?.groups?.["entry"];
+}
+function lines_of(text) {
+  return text.trimEnd().split("\n");
+}
+function frame_of(text) {
+  return lines_of(text).filter((line) => entry_of(line) === void 0).join("\n");
+}
+function entries_of(text) {
+  return new Set(lines_of(text).flatMap((line) => entry_of(line) ?? []));
+}
+function missing_from(entries, other) {
+  return [...entries].filter((entry) => !other.has(entry));
+}
+function moved_entries(before, after) {
+  if (frame_of(before) !== frame_of(after)) return void 0;
+  const was = entries_of(before);
+  const is = entries_of(after);
+  return [...missing_from(is, was), ...missing_from(was, is)];
+}
+function tests_of(entries) {
+  return [...LIST_TESTS, ...entries];
+}
+async function base_text() {
+  try {
+    return await git_command.show_file(`${await git_command.change_base()}:${PURE_FILES_PATH}`);
+  } catch {
+    return void 0;
+  }
+}
+async function read_moved(root, changed) {
+  if (changed?.includes(PURE_FILES_PATH) !== true) return void 0;
+  const before = await base_text();
+  const after = file_reader.read_if_readable(path.join(root, PURE_FILES_PATH));
+  if (before === void 0 || after === void 0) return void 0;
+  return moved_entries(before, after);
+}
+var pure_files_entries = { PURE_FILES_PATH, moved_entries, read_moved, tests_of };
+
+// scripts/test/test-related-scope.ts
+import path2 from "node:path";
+var RELATABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte"
+]);
+var { WHOLE_SUITE_FILES } = whole_suite_files;
+var { UNREADABLE_REASON } = changed_file_scope;
+var NOTHING_RELATABLE_REASON = "no changed file is one a test can import or read";
+var NO_MAP_REASON = "no test-read map covers the changed non-code file";
+var { UNMOVED_REASON } = since_green;
+var WHOLE_SUITE_SUFFIX = "affects every test";
+var UNRECORDED_SUFFIX = "is read by no recorded test";
+var FALLBACK_KINDS = [
+  { kind: "unreadable", reason: UNREADABLE_REASON },
+  { kind: "nothing-relatable", reason: NOTHING_RELATABLE_REASON },
+  { kind: "no-map", reason: NO_MAP_REASON },
+  { kind: "whole-suite-file", reason: WHOLE_SUITE_SUFFIX },
+  { kind: "unrecorded-file", reason: UNRECORDED_SUFFIX }
+];
+var OTHER_FALLBACK = "other";
+var COMMAND_NAME = "test:related";
+var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
+var { LISTED_FILE_LIMIT } = changed_file_scope;
+var VOCABULARY = {
+  label: COMMAND_LABEL,
+  fallback_suffix: "running the full unit suite instead",
+  narrowed_suffix: "running only the tests related to them"
+};
+var NONE_SUFFIX = "running no tests";
+var RUN_FLAG = "--run";
+var RELATED_SUBCOMMAND = "related";
+var RUN_SUBCOMMAND = "run";
+function is_relatable(file_path) {
+  return RELATABLE_EXTENSIONS.has(path2.extname(file_path));
+}
+function is_moved(request, file) {
+  return request.since_map?.includes(file) !== true;
+}
+function is_code_input(request, file) {
+  if (!is_relatable(file)) return false;
+  if (is_moved(request, file)) return true;
+  return request.naming_moved?.has(file) === true;
+}
+function all_scope(reason, triggers = [], root = "") {
+  return { mode: "all", files: triggers.map((file) => path2.join(root, file)), reason };
+}
+function resolve_through_map(others, request) {
+  const { map, recorded } = request;
+  if (others.length === 0) return { files: [], unread: [] };
+  if (map === void 0) return { reason: `${NO_MAP_REASON} ${String(others[0])}` };
+  const unread = others.filter((file) => test_read_map.readers_of(map, file).length === 0);
+  const unknown = unread.filter(
+    (file) => is_moved(request, file) && !recorded.has(file) && !test_read_map.in_unread_directory(map, file)
+  );
+  if (unknown.length > 0) {
+    return { reason: `${String(unknown[0])} ${UNRECORDED_SUFFIX}`, triggers: unknown };
+  }
+  return { files: others.flatMap((file) => test_read_map.readers_of(map, file)), unread };
+}
+function code_readers(code, map) {
+  if (map === void 0) return [];
+  return code.flatMap((file) => test_read_map.readers_of(map, file));
+}
+function none_scope(unread, root) {
+  const files = unread.map((file) => path2.join(root, file));
+  return { mode: "none", files, reason: `${String(files.length)} changed file(s) reach no test` };
+}
+function narrowed_scope(selection, request) {
+  if (selection.files.length === 0 && selection.unread.length > 0) {
+    return none_scope(selection.unread, request.root);
+  }
+  const present = [...new Set(selection.files)].map((file) => path2.join(request.root, file)).filter((file) => request.is_present(file));
+  if (present.length === 0) return all_scope(NOTHING_RELATABLE_REASON);
+  return { mode: "related", files: present, reason: `${String(present.length)} related file(s)` };
+}
+function left_out(request, code) {
+  return (request.since_map ?? []).filter((file) => !code.includes(file));
+}
+function without_pure_entries(changed, entries) {
+  if (entries === void 0) return { files: [], unread: changed };
+  const rest = changed.filter((file) => file !== pure_files_entries.PURE_FILES_PATH);
+  return { files: pure_files_entries.tests_of(entries), unread: rest };
+}
+function is_narrowed(request, file) {
+  return request.every_test_importers?.has(file) === true;
+}
+function direct_selection(request, changed) {
+  const moved = changed.filter((file) => is_narrowed(request, file) && is_moved(request, file));
+  const tests = moved.map((file) => request.every_test_importers?.get(file) ?? []);
+  return { files: tests.flat(), unread: moved.filter((_file, index) => tests[index]?.length === 0) };
+}
+function whole_suite_triggers(request, changed) {
+  return changed.filter(
+    (file) => WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file)
+  );
+}
+function resolve_read(request, entry_tests) {
+  const { changed, root } = request;
+  const whole = whole_suite_triggers(request, changed);
+  if (whole.length > 0) return all_scope(`${String(whole[0])} ${WHOLE_SUITE_SUFFIX}`, whole, root);
+  const direct = direct_selection(request, changed);
+  const code = changed.filter((file) => !is_narrowed(request, file) && is_code_input(request, file));
+  const resolution = resolve_through_map(
+    changed.filter((file) => !is_relatable(file) && is_moved(request, file)),
+    request
+  );
+  if ("reason" in resolution) return all_scope(resolution.reason, resolution.triggers, root);
+  const files = [
+    ...code,
+    ...code_readers(code, request.map),
+    ...resolution.files,
+    ...entry_tests,
+    ...direct.files
+  ];
+  const unread = [...resolution.unread, ...left_out(request, code), ...direct.unread];
+  return narrowed_scope({ files, unread }, request);
+}
+function resolve_scope(request) {
+  if (request.changed === void 0) return all_scope(UNREADABLE_REASON);
+  const pure = without_pure_entries(request.changed, request.pure_entries);
+  return resolve_read({ ...request, changed: pure.unread }, pure.files);
+}
+function describe_scope(scope, root) {
+  if (scope.mode !== "none") return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+  const listing = changed_file_scope.format_file_list(scope.files, root);
+  return `${COMMAND_LABEL}: ${scope.reason} \u2014 ${NONE_SUFFIX}.
+${listing}`;
+}
+function reason_kind(reason) {
+  return FALLBACK_KINDS.find((entry) => reason.includes(entry.reason))?.kind ?? OTHER_FALLBACK;
+}
+function fallback_kind(output) {
+  const prefix = `${COMMAND_LABEL}: `;
+  const suffix = ` \u2014 ${VOCABULARY.fallback_suffix}.`;
+  const line = output.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
+  if (line === void 0) return void 0;
+  return reason_kind(line.slice(prefix.length, -suffix.length));
+}
+function scope_kind(scope) {
+  return scope.mode === "all" ? reason_kind(scope.reason) : scope.mode;
+}
+function is_unmoved(output) {
+  const line = `${COMMAND_LABEL}: ${UNMOVED_REASON} \u2014 ${NONE_SUFFIX}.`;
+  return output.split("\n").some((candidate) => candidate.trim() === line);
+}
+function vitest_arguments(scope, extra_flags = []) {
+  if (scope.mode !== "related") return [RUN_SUBCOMMAND, ...extra_flags];
+  return [RELATED_SUBCOMMAND, ...scope.files, RUN_FLAG, ...extra_flags];
+}
+var related_scope = {
+  COMMAND_LABEL,
+  COMMAND_NAME,
+  LISTED_FILE_LIMIT,
+  NOTHING_RELATABLE_REASON,
+  NO_MAP_REASON,
+  UNMOVED_REASON,
+  UNREADABLE_REASON,
+  describe_scope,
+  fallback_kind,
+  is_relatable,
+  is_unmoved,
+  resolve_scope,
+  scope_kind,
+  vitest_arguments
+};
+
+export {
+  pure_files_entries,
+  related_scope
+};

package/dist/commands/chunk-ZGANVZCA.js

@@ -0,0 +1,92 @@
+import {
+  run_ship_body_draft
+} from "./chunk-NVMV7BYX.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/run/ship/run-ship-args.ts
+var FIRST = 0;
+var NUMBER_GROUP = 1;
+var EXTRA_CITE_START = 1;
+var TRAILING_ISSUE_PATTERN = /#([1-9]\d*)\s*$/u;
+var NOTIFY_OPTIONS = ["notify-message", "notify-message-file"];
+var { BODY_FILE_OPTION, body_arguments } = run_ship_body_draft;
+var UNPINNED_OK_OPTION = "unpinned-ok";
+var OPTIONS = {
+  [NOTIFY_OPTIONS[0]]: { type: "string" },
+  [NOTIFY_OPTIONS[1]]: { type: "string" },
+  [BODY_FILE_OPTION]: { type: "string" },
+  review: { type: "boolean" },
+  // Hand the region to a detached supervisor (`run-ship-detach.ts`), print the
+  // report a stopped supervisor left, and carry follow-up citations as options so the supervisor's
+  // command line still ends with its title.
+  detach: { type: "boolean" },
+  log: { type: "string" },
+  cite: { type: "string", multiple: true },
+  // Forwarded to round 1's `run:review`, the only way past a change no test can pin under `--review`.
+  [UNPINNED_OK_OPTION]: { type: "string" }
+};
+function notify_arguments(values) {
+  return NOTIFY_OPTIONS.flatMap((option) => {
+    const value = values[option];
+    return value === void 0 ? [] : [`--${option}`, value];
+  });
+}
+function issue_number(title) {
+  return TRAILING_ISSUE_PATTERN.exec(title)?.[NUMBER_GROUP];
+}
+function unpinned_arguments(reason) {
+  return reason === void 0 ? [] : [`--${UNPINNED_OK_OPTION}`, reason];
+}
+function is_stray_unpinned_ok(values) {
+  const reason = values[UNPINNED_OK_OPTION];
+  if (reason === void 0) return false;
+  return values.review !== true || reason.trim() === "";
+}
+function is_refused_option(values) {
+  return is_stray_unpinned_ok(values) || values[BODY_FILE_OPTION] === cli_body.STDIN_PATH;
+}
+function ship_args(title, rest, values) {
+  const number = issue_number(title);
+  const cites = [...rest, ...values.cite ?? []];
+  if (number === void 0 || cites.some((token) => !issue_number_shape.is_issue_number(token))) {
+    return void 0;
+  }
+  return {
+    title,
+    number,
+    notify: notify_arguments(values),
+    body: body_arguments(values[BODY_FILE_OPTION]),
+    body_path: values[BODY_FILE_OPTION],
+    cites,
+    is_review: values.review === true,
+    is_detach: values.detach === true,
+    unpinned_ok: unpinned_arguments(values[UNPINNED_OK_OPTION])
+  };
+}
+function log_command(number, positionals) {
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(number) && positionals.length === 0 ? { kind: "log", number } : void 0;
+}
+function command_of(values, positionals) {
+  if (values.log !== void 0) return log_command(values.log, positionals);
+  if (is_refused_option(values)) return void 0;
+  const title = positionals[FIRST];
+  const args = title === void 0 ? void 0 : ship_args(title, positionals.slice(EXTRA_CITE_START), values);
+  return args === void 0 ? void 0 : { kind: "ship", args };
+}
+function parse(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  return parsed === void 0 ? void 0 : command_of(parsed.values, parsed.positionals);
+}
+var run_ship_args = { parse };
+
+export {
+  run_ship_args
+};