@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-HRN73FQJ.js

@@ -0,0 +1,77 @@
+import {
+  inherited_scope
+} from "./chunk-5OF2B4BF.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+
+// scripts/run/ship/run-ship-lap.ts
+import { z } from "zod";
+var ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
+var PARENT_SEPARATOR = " \u203A ";
+var STARTUP_STEP = "startup";
+var lap_scope_schema = z.object({
+  issue: z.number(),
+  stage: z.string(),
+  parent: z.string().optional()
+});
+var STEP = {
+  PRECONDITIONS: "preconditions",
+  SCOPED_PAIR: "scoped pair",
+  GATE: "josh gate",
+  OVERLAP_WAIT: "overlap wait",
+  LOCAL_COMMIT: "local commit",
+  MERGE: "merge",
+  PUSH: "push",
+  COMMIT: "josh git"
+};
+var scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema);
+async function to_ledger(lap) {
+  await lane_ledger_write.record_ship_lap(lap);
+}
+async function within(issue, stage, run, parent) {
+  return await scope.within({ issue: Number(issue), stage, parent }, run);
+}
+function current_scope() {
+  return scope.current();
+}
+function environment(parent) {
+  const current = current_scope();
+  if (current === void 0) return {};
+  return {
+    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
+  };
+}
+function lap_of(current, step, started_ms, note) {
+  const { parent, ...place } = current;
+  const name = parent === void 0 ? step : `${parent}${PARENT_SEPARATOR}${step}`;
+  return { ...place, step: name, elapsed_ms: performance.now() - started_ms, ...note };
+}
+function no_note() {
+  return {};
+}
+var startup = { recorded: false };
+async function record_startup(current, sink, is_wanted) {
+  if (!is_wanted || startup.recorded || scope.local() !== void 0) return;
+  startup.recorded = true;
+  await sink(lap_of(current, STARTUP_STEP, 0, {}));
+}
+async function timed(step, run, { sink = to_ledger, note_of = no_note, startup: with_startup } = {}) {
+  const current = current_scope();
+  if (current === void 0) return await run();
+  await record_startup(current, sink, with_startup !== false);
+  const started_ms = performance.now();
+  const noted = { note: {} };
+  try {
+    const result = await run();
+    noted.note = note_of(result);
+    return result;
+  } finally {
+    await sink(lap_of(current, step, started_ms, noted.note));
+  }
+}
+var run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
+
+export {
+  run_ship_lap
+};

package/dist/commands/chunk-HSZECERZ.js

@@ -0,0 +1,271 @@
+import {
+  test_related
+} from "./chunk-JU2MAYQ3.js";
+import {
+  test_unit_guard
+} from "./chunk-KWLNK2NJ.js";
+import {
+  gate_log,
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  moved_paths
+} from "./chunk-PBAEJ5PT.js";
+import {
+  review_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  verification_inputs
+} from "./chunk-EHPTXSAT.js";
+import {
+  NOTHING_TO_CHECK_MARKER,
+  NOT_USED_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  josh_verdict
+} from "./chunk-JTU5A4JI.js";
+import {
+  status_icons
+} from "./chunk-65E4OZJ7.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  GATE_COMMAND
+} from "./chunk-TBIX5FRN.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/gate/gate-report.ts
+var { FAIL_ICON, PASS_ICON, WARN_ICON } = status_icons;
+function is_gate_step_failed(result) {
+  return buffered_process.is_process_failed(result);
+}
+function is_skip_notice(result) {
+  return result.output.includes(test_unit_guard.SKIP_MARKER);
+}
+var WARNING_MARKERS = ["warning", "Warning", "\u26A0"];
+function has_warnings(result) {
+  return WARNING_MARKERS.some((marker) => result.output.includes(marker));
+}
+var SAFE_CHAIN_BANNER = "safe-chain is not available";
+var PNPM_SCRIPT_HEADER = "$ ";
+var LINT_FILE_PREFIX = "  - ";
+function checker_lines(result) {
+  return result.output.split("\n").filter((line) => !line.includes(SAFE_CHAIN_BANNER) && !line.startsWith(PNPM_SCRIPT_HEADER));
+}
+function has_checker_warning(result) {
+  if (!gate_labels.WARNING_CHECKER_LABELS.includes(result.label)) return false;
+  return checker_lines(result).filter((line) => result.label !== gate_labels.LINT_LABEL || !line.startsWith(LINT_FILE_PREFIX)).some((line) => WARNING_MARKERS.some((marker) => line.includes(marker)));
+}
+function is_unverified_skip(result) {
+  return checker_lines(result).some(
+    (line) => line.includes(test_unit_guard.SKIP_MARKER) && !line.includes(NOT_USED_MARKER)
+  );
+}
+function has_nothing_to_say(result) {
+  return !is_unverified_skip(result) && !has_checker_warning(result);
+}
+var IDLE_MARKERS = [test_unit_guard.SKIP_MARKER, NOTHING_TO_CHECK_MARKER];
+function is_idle_line(line) {
+  return IDLE_MARKERS.some((marker) => line.includes(marker));
+}
+function is_tool_line(line) {
+  return line.trim() !== "";
+}
+function is_idle(result) {
+  const lines = checker_lines(result).filter((line) => is_tool_line(line));
+  return lines.length > 0 && lines.every((line) => is_idle_line(line));
+}
+function should_print_body(result, is_verbose) {
+  if (is_verbose || is_gate_step_failed(result)) return true;
+  return is_skip_notice(result) || has_warnings(result);
+}
+var SECONDS_DECIMALS = 1;
+function format_seconds(elapsed_ms) {
+  return `${(elapsed_ms / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
+}
+function gate_step_header(result) {
+  const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON;
+  const timing = result.reused_at === void 0 ? format_seconds(result.elapsed_ms) : `reused \u2014 inputs unchanged since it passed at ${result.reused_at}`;
+  return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`;
+}
+function print_gate_step(result, is_verbose) {
+  process.stdout.write(`
+${gate_step_header(result)}
+`);
+  if (should_print_body(result, is_verbose) && result.output) {
+    process.stdout.write(`${result.output}
+`);
+  }
+}
+function format_failure_actions(failed) {
+  if (failed.length === 0) return "";
+  const lines = failed.map(
+    (result) => verification_tail.format_rerun(result.label, `pnpm ${result.command}`)
+  );
+  return `${GATE_COMMAND} \u2014 next:
+${lines.join("\n")}
+`;
+}
+function format_budget_notes(results) {
+  const lines = results.flatMap(
+    (result) => result.budget_note === void 0 ? [] : `  ${WARN_ICON} ${result.label} \u2014 ${result.budget_note}`
+  );
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+}
+function format_green_verdict(results, total) {
+  const has_skip = results.some((result) => is_skip_notice(result));
+  const skipped = has_skip ? results.filter((result) => is_idle(result)).length : 0;
+  const ran = results.length - skipped;
+  if (ran === 0) return josh_verdict.format_gate_unverified(skipped, total);
+  return josh_verdict.format_gate_passed({ ran, skipped }, total);
+}
+function print_gate_summary(results, report, log_path) {
+  const failed = results.filter((result) => is_gate_step_failed(result));
+  const total = format_seconds(report.elapsed_ms);
+  const verdict = failed.length === 0 ? format_green_verdict(results, total) : josh_verdict.format_gate_failed(failed.map((result) => result.label).join(", "), total);
+  const failures = `${format_budget_notes(results)}${format_failure_actions(failed)}`;
+  process.stdout.write(
+    `
+${verification_tail.format_tail({ failures, log: { path: log_path }, verdict })}`
+  );
+}
+function report_gate_steps(results, report) {
+  for (const result of results) print_gate_step(result, report.is_verbose);
+  const entries = results.map((result) => ({
+    header: gate_step_header(result),
+    output: result.output
+  }));
+  const written_log = gate_log.write_gate_log(entries, report.log_path);
+  print_gate_summary(results, report, written_log);
+  return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label);
+}
+var gate_report = {
+  format_budget_notes,
+  format_failure_actions,
+  has_checker_warning,
+  has_nothing_to_say,
+  is_gate_step_failed,
+  report_gate_steps
+};
+
+// scripts/gate/check-inputs.ts
+import path from "node:path";
+function prettier_ignored(root) {
+  const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name));
+  return async function is_ignored(relative) {
+    try {
+      const prettier = await import("prettier");
+      const info = await prettier.getFileInfo(path.join(root, relative), {
+        ignorePath: ignore_path
+      });
+      return info.ignored;
+    } catch {
+      return false;
+    }
+  };
+}
+async function reads_any(declaration, paths, is_ignored, root) {
+  if (declaration.reads === "recorded") return await test_related.reaches_tests(root, paths);
+  const { is_input } = declaration;
+  if (is_input === void 0) return true;
+  const answers = await Promise.all(
+    paths.map(async (relative) => await is_input(relative, is_ignored))
+  );
+  return answers.includes(true);
+}
+async function touches_inputs(label, paths, is_ignored, root = PROJECT_ROOT) {
+  const declaration = verification_inputs.declaration_of(label);
+  if (declaration === void 0 || verification_inputs.configures(label, paths, root)) return true;
+  return await reads_any(declaration, paths, is_ignored, root);
+}
+var check_inputs = { prettier_ignored, touches_inputs };
+
+// scripts/gate/check-reuse.ts
+var CHECK_PREFIX = "josh-gate-check-";
+function declared_inputs(label) {
+  if (!verification_inputs.is_declared(label)) return void 0;
+  return {
+    fingerprint: () => verification_inputs.fingerprint([label]),
+    touches: async (moved, context) => await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root)
+  };
+}
+function check_stamp(inputs) {
+  return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint);
+}
+function default_records(label) {
+  return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT);
+}
+async function is_stamp_reusable(inputs, stamp, context) {
+  const moved = await moved_paths.moved_since(stamp, context.tree);
+  if (moved === void 0 || !check_stamp(inputs).describes_inputs(stamp)) return false;
+  return !await inputs.touches(moved, context);
+}
+async function reused_at(label, inputs, context) {
+  if (inputs === void 0) return void 0;
+  const stamp = check_stamp(inputs).read(context.records(label));
+  if (stamp === void 0) return void 0;
+  return await is_stamp_reusable(inputs, stamp, context) ? stamp.taken_at : void 0;
+}
+async function read_root() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return void 0;
+  }
+}
+async function reusable_checks(labels, tree, records = default_records, inputs_of = declared_inputs) {
+  const root = await read_root();
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) };
+  const answers = await Promise.all(
+    labels.map(
+      async (label) => [label, await reused_at(label, inputs_of(label), context)]
+    )
+  );
+  return new Map(answers.flatMap(([label, at]) => at === void 0 ? [] : [[label, at]]));
+}
+function recordable_inputs(result, inputs_of) {
+  const is_quiet_pass = !gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result);
+  return is_quiet_pass ? inputs_of(result.label) : void 0;
+}
+function write_records(results, tree, records, inputs_of) {
+  for (const result of results) {
+    const inputs = recordable_inputs(result, inputs_of);
+    if (inputs !== void 0) {
+      check_stamp(inputs).write(tree.files, records(result.label), tree.base);
+    }
+  }
+}
+async function record_green_checks(results, tree, records = default_records, inputs_of = declared_inputs) {
+  try {
+    const after = await review_tree.read_changed_tree();
+    if (JSON.stringify(after) !== JSON.stringify(tree.files)) return;
+    write_records(results, { files: after, base: tree.base }, records, inputs_of);
+  } catch {
+  }
+}
+var check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks };
+
+export {
+  gate_report,
+  check_reuse
+};

package/dist/commands/chunk-HYE3MBAN.js

@@ -0,0 +1,113 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-LS7P324N.js";
+import {
+  ISSUE_FIELDS,
+  STATE_AND_RELATIONS_FIELDS,
+  git_gh_issue_graphql,
+  git_gh_issue_rest,
+  issue_fields_schema
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_transport
+} from "./chunk-LX2ENXHZ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-batch-graphql.ts
+import { z } from "zod";
+var ALIAS_PREFIX = "issue";
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+var repository_schema = z.record(z.string(), z.unknown());
+var data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
+var response_schema = z.looseObject({ data: data_schema });
+function alias_of(issue_number) {
+  return `${ALIAS_PREFIX}${String(issue_number)}`;
+}
+function query_of(issue_numbers) {
+  const aliases = issue_numbers.map(
+    (issue_number) => `${alias_of(issue_number)}: issueOrPullRequest(number: ${String(issue_number)}) { ... on Issue { ${ISSUE_FIELDS} } }`
+  );
+  return `query($owner: String!, $name: String!) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
+}`;
+}
+function answered(json) {
+  return { kind: "read", json };
+}
+function to_read(issue, fields) {
+  const issue_json = git_gh_issue_rest.to_gh_issue(
+    git_gh_issue_graphql.to_rest_issue(issue),
+    git_gh_issue_rest.split_fields(fields),
+    git_gh_issue_graphql.to_blocked_by(issue)
+  );
+  return answered(JSON.stringify(issue_json));
+}
+async function query_chunk(issue_numbers, variables) {
+  const json = await git_gh_transport.query_partial({ query: query_of(issue_numbers), variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, response_schema)?.data;
+}
+function answered_reads(request, data) {
+  return request.issue_numbers.flatMap((issue_number) => {
+    const issue = issue_fields_schema.safeParse(data.repository[alias_of(issue_number)]);
+    return issue.success ? [[issue_number, to_read(issue.data, request.fields)]] : [];
+  });
+}
+function with_chunk(batch, request, data) {
+  if (data === void 0) return batch;
+  return {
+    reads: new Map([...batch.reads, ...answered_reads(request, data)]),
+    cost: batch.cost + data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+function empty_batch() {
+  return { reads: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
+}
+async function read_many(issue_numbers, repo, fields = STATE_AND_RELATIONS_FIELDS) {
+  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
+  let batch = empty_batch();
+  if (variables === void 0) return batch;
+  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
+  for (const chunk of chunks) {
+    const request = { issue_numbers: chunk, fields };
+    batch = with_chunk(batch, request, await query_chunk(chunk, variables));
+  }
+  return batch;
+}
+var git_gh_issue_batch_graphql = { answered, empty_batch, read_many };
+
+// scripts/gh/git-gh-issue-batch-read.ts
+async function read_each(issue_numbers, reader) {
+  const { reads } = await git_gh_issue_batch_graphql.read_many(
+    issue_numbers,
+    reader.repo,
+    reader.fields
+  );
+  return await Promise.all(
+    issue_numbers.map(async (issue_number) => {
+      const read = reads.get(issue_number);
+      const value = read?.kind === "read" ? reader.from_json(read.json) : await reader.read_rest(issue_number);
+      return [issue_number, value];
+    })
+  );
+}
+async function read_across(issues, reader_for) {
+  const repos = [...new Set(issues.map((issue) => issue.repo))];
+  const reads = await Promise.all(
+    repos.map(async (repo) => {
+      const numbers = issues.filter((issue) => issue.repo === repo).map((issue) => issue.number);
+      return new Map(await read_each(numbers, reader_for(repo)));
+    })
+  );
+  return issues.map((issue) => reads[repos.indexOf(issue.repo)]?.get(issue.number));
+}
+var git_gh_issue_batch_read = { read_across, read_each };
+
+export {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+};

package/dist/commands/chunk-IAB6LCJL.js

@@ -0,0 +1,18 @@
+import {
+  hook_decision
+} from "./chunk-GB2BRQVL.js";
+
+// scripts/run/run-retrospective.ts
+var RETROSPECTIVE_ENV_KEY = "JOSH_RETROSPECTIVE";
+function is_enabled() {
+  return hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY);
+}
+function is_owed(facts) {
+  if (!facts.is_retrospective_enabled) return false;
+  return !facts.is_lane_child && !facts.is_retrospective_done && !facts.is_consumer;
+}
+var run_retrospective = { is_enabled, is_owed };
+
+export {
+  run_retrospective
+};

package/dist/commands/chunk-IAGENI2U.js

@@ -0,0 +1,42 @@
+import {
+  has_stderr_field
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/gh/git-gh-helpers.ts
+function parse_pr_state_string(result) {
+  const trimmed = result.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function is_pr_already_exists_message(error_message) {
+  return error_message.toLowerCase().includes("already exists");
+}
+function get_error_message_with_stderr(error) {
+  if (!(error instanceof Error)) return String(error);
+  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
+${error.stderr}`;
+  return error.message;
+}
+function handle_pr_create_error(error) {
+  const error_message = get_error_message_with_stderr(error);
+  if (is_pr_already_exists_message(error_message)) {
+    throw new Error("PR_ALREADY_EXISTS");
+  }
+  throw error;
+}
+var git_gh_helpers = {
+  parse_pr_state_string,
+  get_error_message_with_stderr,
+  handle_pr_create_error
+};
+
+// scripts/gh/git-gh-rest-state.ts
+var MERGED_STATE = "MERGED";
+function to_gh_state(state) {
+  return state?.toUpperCase();
+}
+
+export {
+  git_gh_helpers,
+  MERGED_STATE,
+  to_gh_state
+};

package/dist/commands/chunk-ICPVBHIX.js

@@ -0,0 +1,48 @@
+import {
+  run_carry_reclaim
+} from "./chunk-SKGDMAIA.js";
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_provider,
+  cost_transcript
+} from "./chunk-DDZVMXZD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/wake/run-wake-handoff.ts
+import { existsSync } from "node:fs";
+function session_owner(session) {
+  if (session.provider === agent_provider.OPENAI_PROVIDER) {
+    return { session: session.session_id, is_headless: true };
+  }
+  const directory = cost_transcript.transcript_directory(session.worktree);
+  const transcript = run_carry_conversation.transcript_of(session.session_id, directory);
+  return { transcript, is_headless: true };
+}
+function hand_off(target) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried" || read.carry.is_handed_off === true) return;
+  stamp_file.replace_stamp(target, { ...read.carry, is_handed_off: true });
+}
+function hand_to(target, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return;
+  run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider });
+}
+function hand_on(target, owner, pid) {
+  if (owner.transcript === void 0 && owner.session === void 0) return;
+  const process_owner = run_carry.owner_of(pid, void 0, owner.transcript);
+  run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session });
+}
+function has_session_begun(carry) {
+  return carry.owner_transcript === void 0 || existsSync(carry.owner_transcript);
+}
+var run_wake_handoff = { hand_off, session_owner, hand_to, hand_on, has_session_begun };
+
+export {
+  run_wake_handoff
+};