@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/chunk-Y4EBUI6M.js

@@ -0,0 +1,237 @@
+import {
+  issue_park
+} from "./chunk-OIX2363L.js";
+import {
+  run_stalled
+} from "./chunk-S4M6UWR2.js";
+import {
+  agent_worker_profile
+} from "./chunk-FVDQNMP6.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+import {
+  run_event_stream_emit
+} from "./chunk-OKZWEVR4.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  RUN_STALLED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  distributed_paths
+} from "./chunk-66TGK5XL.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  stamp_file
+} from "./chunk-QWWTC3XR.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+
+// scripts/run/park/run-stalled-park.ts
+var { PARK } = run_event_stream.EVENT_KIND;
+async function apply(issue, comment, cause, fields = {}) {
+  const park_write = await issue_park.apply(issue, RUN_STALLED_LABEL, comment);
+  if (!park_write.is_labelled) return false;
+  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, cause), /* @__PURE__ */ new Date(), fields);
+  return true;
+}
+var run_stalled_park = { apply };
+
+// scripts/run/park/run-park-escalate.ts
+var ESCALATE_FLAG = "--escalate";
+var OPTIONS = { escalate: { type: "string" } };
+var DISABLED_NOTE = `run:park ${ESCALATE_FLAG}: refused \u2014 this repository's package.json does not set josh.worker.escalate to true.`;
+function is_requested(argv) {
+  return argv.some((token) => token === ESCALATE_FLAG || token.startsWith(`${ESCALATE_FLAG}=`));
+}
+function is_enabled(directory) {
+  const result = agent_worker_profile.read(directory);
+  return result.kind === "settings" && result.settings.escalate;
+}
+function reason_of(value) {
+  return value?.trim() ?? "";
+}
+function escalation_of(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue = issue_number_shape.single_of(parsed.positionals);
+  const reason = reason_of(parsed.values.escalate);
+  return issue === void 0 || reason === "" ? void 0 : { issue, reason };
+}
+function refusal_of(escalation, directory, usage) {
+  if (escalation === void 0) return usage;
+  return is_enabled(directory) ? void 0 : DISABLED_NOTE;
+}
+function accepted(argv, directory, usage) {
+  const escalation = escalation_of(argv);
+  const refusal = refusal_of(escalation, directory, usage);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal === void 0 ? escalation : void 0;
+}
+function comment_of(escalation) {
+  const { issue, reason } = escalation;
+  return [
+    `Parked with \`${RUN_STALLED_LABEL}\`: ${run_stalled.ESCALATION_REQUESTED.why}`,
+    `- Reason: ${reason}`,
+    `- Next: the backlogrun drive resumes it one \`worker:<name>\` profile up, or hands it to a person at the top profile; without a drive, give it a stronger profile, ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+}
+async function park(argv, directory, usage) {
+  const escalation = accepted(argv, directory, usage);
+  if (escalation === void 0) return void 0;
+  const { short } = run_stalled.escalation_requested(escalation.reason);
+  const is_parked = await run_stalled_park.apply(escalation.issue, comment_of(escalation), short);
+  console.info(`escalate ${session_cite.issue(escalation.issue)} \u2014 parked: ${String(is_parked)}`);
+  return is_parked ? escalation.issue : void 0;
+}
+var run_park_escalate = { ESCALATE_FLAG, is_enabled, is_requested, park };
+
+// scripts/agent/lane-instructions.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/cost-runtime/cost-tokens.ts
+var ASCII_CHARS_PER_TOKEN = 3;
+var WIDE_TOKENS_PER_CHAR = 1;
+var ASCII_LIMIT = 128;
+function count_chars(text) {
+  let ascii_chars = 0;
+  let wide_chars = 0;
+  for (const char of text) {
+    if ((char.codePointAt(0) ?? 0) < ASCII_LIMIT) ascii_chars += 1;
+    else wide_chars += 1;
+  }
+  return { ascii_chars, wide_chars };
+}
+function estimate(text) {
+  const { ascii_chars, wide_chars } = count_chars(text);
+  return Math.round(ascii_chars / ASCII_CHARS_PER_TOKEN) + wide_chars * WIDE_TOKENS_PER_CHAR;
+}
+function ascii_bytes_to_tokens(bytes) {
+  return Math.round(bytes / ASCII_CHARS_PER_TOKEN);
+}
+var cost_tokens = {
+  ASCII_CHARS_PER_TOKEN,
+  count_chars,
+  estimate,
+  ascii_bytes_to_tokens
+};
+
+// scripts/agent/lane-instructions.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/agent/lane-instructions.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 LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
+var WORKFLOW_ENTRY = "fullrun-lane.md";
+var WORKFLOW_GUIDE = `A headless fullrun lane child runs pnpm josh doc:read ${WORKFLOW_ENTRY} instead of workflow-commands/SKILL.md, fullrun.md or entry-sequence.md. A resumed child follows its resume prompt first. Review sessions do not start a fullrun.`;
+var RULES_FILE = "CLAUDE.md";
+var POINTER_FILE = "AGENTS.md";
+var INCLUDE_PATTERN = /^<!-- include: CLAUDE\.md → "(?<wanted>.+)" -->$/u;
+var PROMPT_FILE_FLAG = "--append-system-prompt-file";
+var SETTINGS_FLAG = "--settings";
+var PROMPT_FILE_PREFIX = "josh-lane-instructions-";
+var PROMPT_FILE_SUFFIX = ".md";
+var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
+var ESCALATION_GUIDE = [
+  "",
+  "## Escalation",
+  "",
+  '- This Issue needs a stronger model than the one you run on \u2192 `pnpm josh run:park <N> --escalate "<reason>"`, then stop. The reason is required and recorded; the lane resumes one profile up, or goes to a person at the top profile.'
+].join("\n");
+function expand_line(line, rules) {
+  const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
+  if (wanted === void 0) return line;
+  return document_section.section(rules, wanted)?.text;
+}
+function compose(lane_markdown, rules) {
+  const expanded = lane_markdown.split("\n").map((line) => expand_line(line, rules));
+  if (expanded.includes(void 0)) return void 0;
+  return [WORKFLOW_GUIDE, ...expanded].join("\n");
+}
+function rules_sources(cwd) {
+  const imported = distributed_paths.CLAUDE_MD_IMPORT_LINE.replace(/^@/u, "");
+  return [path.join(cwd, RULES_FILE), path.join(cwd, imported)];
+}
+function composed_from(lane_markdown, rules_path) {
+  const rules = document_section.read_optional(rules_path);
+  return rules === void 0 ? void 0 : compose(lane_markdown, rules);
+}
+function rules_set(cwd, package_directory) {
+  const lane_markdown = document_section.read_optional(path.join(package_directory, LANE_DOCUMENT));
+  if (lane_markdown === void 0) return void 0;
+  for (const rules_path of rules_sources(cwd)) {
+    const text = composed_from(lane_markdown, rules_path);
+    if (text !== void 0) return { text, rules_path };
+  }
+  return void 0;
+}
+function composed_set(cwd, package_directory, is_worker = false) {
+  const set = rules_set(cwd, package_directory);
+  if (set === void 0 || !is_worker || !run_park_escalate.is_enabled(cwd)) return set;
+  return { ...set, text: `${set.text}${ESCALATION_GUIDE}` };
+}
+function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
+  return composed_set(cwd, package_directory)?.text;
+}
+function written(text) {
+  const file_path = stamp_file.stamp_path(PROMPT_FILE_PREFIX, text, PROMPT_FILE_SUFFIX);
+  if (stamp_file.read_stamp_text(file_path) === text) return file_path;
+  try {
+    return stamp_file.replace_text_stamp(file_path, text);
+  } catch {
+    return void 0;
+  }
+}
+function excluded_settings(rules_path, cwd) {
+  return JSON.stringify({ claudeMdExcludes: [rules_path, path.join(cwd, POINTER_FILE)] });
+}
+function flags_of(set, cwd) {
+  const prompt_file = set === void 0 ? void 0 : written(set.text);
+  if (set === void 0 || prompt_file === void 0) return [];
+  return [PROMPT_FILE_FLAG, prompt_file, SETTINGS_FLAG, excluded_settings(set.rules_path, cwd)];
+}
+function flags(cwd = process.cwd(), is_worker = false) {
+  return flags_of(composed_set(cwd, PACKAGE_DIRECTORY, is_worker), cwd);
+}
+function tokens_of(text) {
+  return cost_tokens.estimate(text).toLocaleString("en-US");
+}
+function rules_tokens(rules_path) {
+  return tokens_of(document_section.read_optional(rules_path) ?? "");
+}
+function resident_line(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const rules = rules_tokens(set?.rules_path ?? path.join(cwd, RULES_FILE));
+  const lane_tokens = set === void 0 ? "not composed" : `${tokens_of(set.text)} tok`;
+  return `  resident: lane instructions ${lane_tokens} in place of ${RULES_FILE} ${rules} tok`;
+}
+var lane_instructions = {
+  WORKFLOW_ENTRY,
+  PROMPT_FILE_FLAG,
+  SETTINGS_FLAG,
+  compose,
+  composed_in,
+  flags,
+  resident_line
+};
+
+export {
+  cost_tokens,
+  run_stalled_park,
+  run_park_escalate,
+  lane_instructions
+};

package/dist/commands/chunk-YAU3LYNF.js

@@ -0,0 +1,60 @@
+import {
+  hook_ledger
+} from "./chunk-XHGWMD3L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-demoted.ts
+import { readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var DEMOTED_FILE = ".josh/hook-demoted.json";
+var NOTICE_HEADER = "\u2139 Demoted rule \u2014 this call ran; do not reissue it. The refusal it would have given:\n";
+var INDENT = "	";
+var rules_schema = z.object({ rules: z.array(z.string()) });
+function read_rules(file = DEMOTED_FILE) {
+  try {
+    return new Set(json_value.parse_with(readFileSync(file, "utf8"), rules_schema)?.rules);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function rules(environment = process.env) {
+  return environment["VITEST"] === void 0 ? read_rules() : /* @__PURE__ */ new Set();
+}
+async function write_rules(demoted, file = DEMOTED_FILE) {
+  const sorted = [...demoted].toSorted((left, right) => left.localeCompare(right));
+  const body = JSON.stringify({ rules: sorted }, void 0, INDENT);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${body}
+`);
+}
+function is_demoted(reason, demoted) {
+  return demoted.has(hook_ledger.rule_of(reason));
+}
+function verdict(reasons, demoted) {
+  const blocking = reasons.find((reason) => !is_demoted(reason, demoted));
+  if (blocking !== void 0) return { reason: blocking, notice: void 0, fault: void 0 };
+  const [first] = reasons;
+  return first === void 0 ? void 0 : { reason: void 0, notice: `${NOTICE_HEADER}${first}`, fault: void 0 };
+}
+function refusal_of(notice, demoted) {
+  if (notice?.startsWith(NOTICE_HEADER) !== true) return void 0;
+  const reason = notice.slice(NOTICE_HEADER.length);
+  return is_demoted(reason, demoted) ? reason : void 0;
+}
+var hook_demoted = {
+  DEMOTED_FILE,
+  NOTICE_HEADER,
+  read_rules,
+  refusal_of,
+  rules,
+  verdict,
+  write_rules
+};
+
+export {
+  hook_demoted
+};

package/dist/commands/chunk-YDURQICF.js

@@ -0,0 +1,204 @@
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  git_gh_command
+} from "./chunk-YGFOGA7C.js";
+import {
+  pr_classification
+} from "./chunk-WAEN2RTT.js";
+import {
+  animation_helpers
+} from "./chunk-GO3GH7FG.js";
+import {
+  pr_info_schema
+} from "./chunk-34DND4BA.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-pr-error.ts
+function is_pr_already_exists_message(message) {
+  return message === "PR_ALREADY_EXISTS";
+}
+function has_error_cause(error) {
+  return error.cause instanceof Error && is_pr_already_exists_message(error.cause.message);
+}
+function is_pr_already_exists_error(error) {
+  if (error instanceof Error) {
+    if (is_pr_already_exists_message(error.message)) return true;
+    return has_error_cause(error);
+  }
+  return false;
+}
+var git_pr_error = {
+  is_pr_already_exists_error
+};
+
+// scripts/gh/git-pr-messages.ts
+function display_pr_opened_message() {
+  console.info("");
+  console.info("\u2705 Pull request opened.");
+  console.info("");
+  console.info("`pnpm josh followup` waits for the checks and merges.");
+}
+function display_pr_url(pr_url) {
+  console.info("");
+  console.info(`\u{1F517} PR: ${pr_url}`);
+}
+function display_merged_pr_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Existing PR is already merged. Creating a new PR...");
+  console.info("");
+}
+function display_pr_exists_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Pull request already exists.");
+  console.info("");
+}
+var git_pr_messages = {
+  display_pr_opened_message,
+  display_merged_pr_message,
+  display_pr_exists_message,
+  display_pr_url
+};
+
+// scripts/gh/git-pr.ts
+async function create_pr(title, body, label) {
+  const config = {
+    icon_selector: () => "\u2705",
+    error_message: "Failed to create PR",
+    result_formatter: () => "PR created."
+  };
+  try {
+    return await animation_helpers.execute_with_animation(
+      "Creating pull request...",
+      async () => await git_gh_command.pr_create(title, body, label),
+      config
+    );
+  } catch (error) {
+    if (git_pr_error.is_pr_already_exists_error(error)) {
+      git_pr_messages.display_pr_exists_message();
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function display_pr_url_if_available(branch_name) {
+  const pr_url = await git_gh_command.pr_get_url(branch_name);
+  if (pr_url !== void 0) {
+    git_pr_messages.display_pr_url(pr_url);
+  }
+}
+async function report_open_pr(branch_name, created_url) {
+  git_pr_messages.display_pr_opened_message();
+  if (created_url !== void 0 && created_url.length > 0) {
+    git_pr_messages.display_pr_url(created_url);
+    return;
+  }
+  await display_pr_url_if_available(branch_name);
+}
+var PR_STATE_MERGED = "MERGED";
+async function create_and_report(title, body, branch_name, label) {
+  const created_url = await create_pr(title, body, label);
+  await report_open_pr(branch_name, created_url);
+}
+function parse_pr_state(pr_info_json) {
+  return json_value.parse_with(pr_info_json, pr_info_schema)?.state;
+}
+async function get_pr_state(branch_name) {
+  const pr_info_json = await git_gh_command.pr_view(branch_name);
+  if (pr_info_json.length === 0) return void 0;
+  return parse_pr_state(pr_info_json);
+}
+function is_pr_state_merged(pr_state) {
+  return pr_state === PR_STATE_MERGED;
+}
+async function report_existing_pr(body, branch_name, should_replace_body, label) {
+  await git_gh_command.pr_ensure_classification(branch_name, label);
+  if (should_replace_body) await git_gh_command.pr_update_body(branch_name, body);
+  await report_open_pr(branch_name);
+}
+async function handle_existing_pr(title, body, branch_name, options) {
+  const pr_state_result = await get_pr_state(branch_name);
+  if (is_pr_state_merged(pr_state_result)) {
+    git_pr_messages.display_merged_pr_message();
+    await create_and_report(title, body, branch_name, options.label);
+    return;
+  }
+  await report_existing_pr(body, branch_name, options.should_replace_body, options.label);
+}
+async function create(title, body, branch_name, options) {
+  const { label, should_replace_body = false } = options;
+  const has_pr = await git_gh_command.pr_exists(branch_name);
+  if (!has_pr) {
+    await create_and_report(title, body, branch_name, label);
+    return;
+  }
+  await handle_existing_pr(title, body, branch_name, { label, should_replace_body });
+}
+function build_title(issue_info) {
+  return `${issue_info.title} ${issue_cite.plain_for("github", issue_info.number)}`;
+}
+function build_body(issue_info, extra_body) {
+  const closes = `closes ${issue_cite.plain_for("github", issue_info.number)}`;
+  if (extra_body === void 0) return closes;
+  return `${closes}
+
+${extra_body}`;
+}
+async function body_with_map(issue_info, extra_body) {
+  const body = build_body(issue_info, extra_body);
+  if (acceptance_map.has_map(body)) return body;
+  const map = acceptance_map.skeleton(await git_gh_command.issue_get_body(issue_info.number));
+  return map === void 0 ? body : `${body}
+
+${map}`;
+}
+async function existing_pr_label(branch_name) {
+  if (!await git_gh_command.pr_exists(branch_name) || is_pr_state_merged(await get_pr_state(branch_name))) {
+    return void 0;
+  }
+  return await git_gh_command.pr_get_classification(branch_name);
+}
+async function create_for_issue(issue_info, extra_body, label) {
+  await create(
+    build_title(issue_info),
+    await body_with_map(issue_info, extra_body),
+    issue_info.branch_name,
+    {
+      label,
+      should_replace_body: extra_body !== void 0
+    }
+  );
+}
+async function release_classification(issue_number, branch_name) {
+  const existing_label = await existing_pr_label(branch_name);
+  if (existing_label !== void 0) return existing_label;
+  const issue_json = await git_gh_command.issue_view_json(issue_number, "labels,body");
+  if (issue_json === void 0) {
+    throw new Error(
+      `Could not read issue ${session_cite.issue(issue_number)} for release classification`
+    );
+  }
+  return pr_classification.select_issue_classification(issue_json);
+}
+async function create_with_issue_info(issue_info, extra_body) {
+  const label = await release_classification(issue_info.number, issue_info.branch_name);
+  await create_for_issue(issue_info, extra_body, label);
+}
+var git_pr = {
+  create,
+  create_with_issue_info,
+  release_classification
+};
+
+export {
+  git_pr
+};