@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-LKSSQVDA.js

@@ -0,0 +1,49 @@
+import {
+  core_budget
+} from "./chunk-ZCHZU6NX.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  PACKAGE_JSON,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  INSTALL_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-install.ts
+import { existsSync } from "node:fs";
+var INSTALL_ARGUMENTS = ["install", "--frozen-lockfile"];
+var NO_MANIFEST_OUTPUT = `No ${PACKAGE_JSON} in the lane, so the dependency install was skipped.`;
+function has_manifest(directory) {
+  return existsSync(package_manifest.manifest_path(directory));
+}
+async function install_dependencies(directory) {
+  if (!has_manifest(directory)) return { is_installed: true, output: NO_MANIFEST_OUTPUT };
+  const admitted = await run_startup.waiting("install resource wait");
+  const result = await core_budget.with_command_reservation(
+    core_budget.CORE_WEIGHTS.install,
+    async () => {
+      await admitted();
+      return await run_startup.phase(
+        "dependency install",
+        async () => await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
+          cwd: directory,
+          timeout_ms: INSTALL_TIMEOUT_MS
+        }),
+        { edge_of: (value) => buffered_process.is_process_failed(value) ? "failed" : "done" }
+      );
+    },
+    { memory_mb: core_budget.MEMORY_MB.install, command: "lane install" }
+  );
+  return { is_installed: !buffered_process.is_process_failed(result), output: result.output };
+}
+var lane_install = { install_dependencies };
+
+export {
+  lane_install
+};

package/dist/commands/chunk-LL6G34MF.js

@@ -0,0 +1,93 @@
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/agent/agent-worker-profile.ts
+var { EFFORT_SCHEMA, PROFILE_SCHEMA, WORKER } = agent_profile_schema;
+var CONFIG_KEY = "josh.worker";
+var LABEL_PREFIX = "worker:";
+var UNSET = { kind: "unset" };
+function rejected(note) {
+  return { kind: "rejected", note: `${CONFIG_KEY} ${note}` };
+}
+function schema_rejection(error) {
+  const [issue] = error.issues;
+  if (issue === void 0) return rejected("is invalid");
+  return { kind: "rejected", note: `${issue.path.join(".")}: ${issue.message}` };
+}
+function checked_profile(definition) {
+  const { name, model, effort, when } = definition;
+  const parsed = PROFILE_SCHEMA.safeParse({ role: WORKER, model, effort });
+  if (!parsed.success) {
+    return rejected(
+      `profile ${name}: effort ${effort} is not one of ${EFFORT_SCHEMA.options.join(", ")}`
+    );
+  }
+  const checked = agent_role_profile.validate(parsed.data, `${CONFIG_KEY} profile ${name} model`);
+  return checked.kind === "rejected" ? checked : { kind: "profile", worker: { name, when, agent: checked.profile } };
+}
+function checked_settings(config) {
+  const profiles = [];
+  for (const definition of config.profiles) {
+    const checked = checked_profile(definition);
+    if (checked.kind === "rejected") return checked;
+    profiles.push(checked.worker);
+  }
+  return {
+    kind: "settings",
+    settings: { default: config.default, escalate: config.escalate, profiles }
+  };
+}
+function manifest_value(directory) {
+  const text = file_reader.read_if_readable(package_manifest.manifest_path(directory));
+  if (text === void 0) return {};
+  return json_value.parse_or_undefined(text) ?? {};
+}
+function read(directory) {
+  const parsed = package_manifest.josh_schemas.worker.safeParse(manifest_value(directory));
+  if (!parsed.success) return schema_rejection(parsed.error);
+  const config = parsed.data.josh?.worker;
+  return config === void 0 ? UNSET : checked_settings(config);
+}
+function profile_named(settings, name) {
+  return settings.profiles.find((profile) => profile.name === name);
+}
+function for_labels(settings, labels) {
+  const names = labels.filter((label) => label.startsWith(LABEL_PREFIX)).map((label) => label.slice(LABEL_PREFIX.length));
+  if (names.length > 1) {
+    return rejected(`allows one ${LABEL_PREFIX}<name> label, got ${names.join(", ")}`);
+  }
+  const [name = settings.default] = names;
+  const worker = profile_named(settings, name);
+  if (worker === void 0) return rejected(`has no profile for the label ${LABEL_PREFIX}${name}`);
+  return { kind: "worker", worker, settings };
+}
+async function resolve(directory, fetch_labels) {
+  const result = read(directory);
+  if (result.kind !== "settings") return result;
+  const labels = await fetch_labels();
+  if (labels === void 0) return rejected("could not read the Issue labels");
+  return for_labels(result.settings, labels);
+}
+function next(settings, worker) {
+  const index = settings.profiles.findIndex((profile) => profile.name === worker.name);
+  if (index === -1) return void 0;
+  return settings.profiles[index + 1];
+}
+var agent_worker_profile = { LABEL_PREFIX, for_labels, next, read, resolve };
+
+export {
+  agent_worker_profile
+};

package/dist/commands/chunk-LNQOL2CL.js

@@ -0,0 +1,321 @@
+import {
+  bash_output_cap_reader
+} from "./chunk-JFLFGLE4.js";
+import {
+  cost_tokens,
+  lane_instructions
+} from "./chunk-4I5AA4P5.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/document/entry-read-set.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+// scripts/document/read-set-cost.ts
+var NOTHING = 0;
+var ONE_LINE = 1;
+function cost_of(text) {
+  return { bytes: Buffer.byteLength(text, "utf8"), tokens: cost_tokens.estimate(text) };
+}
+function total(costs) {
+  const running = { bytes: NOTHING, tokens: NOTHING };
+  for (const cost of costs) {
+    running.bytes += cost.bytes;
+    running.tokens += cost.tokens;
+  }
+  return running;
+}
+function add_range(charged, found) {
+  for (let index = found.first_line; index <= found.last_line; index += ONE_LINE) charged.add(index);
+}
+function charged_lines(markdown, headings) {
+  const charged = /* @__PURE__ */ new Set();
+  for (const heading of headings) {
+    const found = document_section.section(markdown, heading);
+    if (found === void 0) return void 0;
+    add_range(charged, found);
+  }
+  return charged;
+}
+function extend_or_start(runs, index) {
+  const current = runs.at(-1);
+  if (current?.at(-1) === index - ONE_LINE) current.push(index);
+  else runs.push([index]);
+}
+function contiguous_runs(charged) {
+  const runs = [];
+  const ascending = [...charged].toSorted((left, right) => left - right);
+  for (const index of ascending) extend_or_start(runs, index);
+  return runs;
+}
+function run_text(lines, run) {
+  return run.map((index) => lines[index] ?? "").join("\n");
+}
+function scoped_file_cost(markdown, headings) {
+  const charged = charged_lines(markdown, headings);
+  if (charged === void 0) return cost_of(markdown);
+  const lines = markdown.split("\n");
+  return total(contiguous_runs(charged).map((run) => cost_of(run_text(lines, run))));
+}
+var read_set_cost = { cost_of, scoped_file_cost, total };
+
+// scripts/document/read-set-point-of-use.ts
+var POINT_OF_USE_FILES = /* @__PURE__ */ new Set([
+  "latest-gate.md",
+  "followup.md",
+  "chain-rule.md",
+  "background-commands.md",
+  "pre-gate-cut.md",
+  "progress-watcher.md",
+  "backlogrun-child.md",
+  "backlogrun-lanes.md",
+  "backlogrun-progress.md",
+  "backlogrun-park.md",
+  "backlogrun-steps.md",
+  // Read only when a delegated unit goes silent or a lane's pull request conflicts with `main` — a
+  // failure path, so a run in which nothing fails never reads it.
+  "backlogrun-recovery.md",
+  // Read only when `run:step` prints `pnpm josh retrospective` at a run's stop position — the very
+  // end of a run, never the entry. Kept out of every entry's read for the
+  // same reason the phase documents above are: no run that never drains its backlog reaches it.
+  "retrospective.md"
+]);
+var DEFERRED_DECISIONS = /* @__PURE__ */ new Set(["delegation.md", "issue-scout.md"]);
+var SPLIT_ASSESSMENT = "split-assessment.md";
+var POINT_OF_USE_BY_ENTRY = /* @__PURE__ */ new Map([
+  ["kickoff", DEFERRED_DECISIONS],
+  ["fullrun", DEFERRED_DECISIONS],
+  ["halfrun", DEFERRED_DECISIONS],
+  ["prrun", DEFERRED_DECISIONS],
+  ["backlogrun", /* @__PURE__ */ new Set([...DEFERRED_DECISIONS, "fullrun.md", SPLIT_ASSESSMENT])],
+  ["lane-child", /* @__PURE__ */ new Set([SPLIT_ASSESSMENT])]
+]);
+var NO_PER_ENTRY_FILES = /* @__PURE__ */ new Set();
+function is_point_of_use(entry, file) {
+  if (POINT_OF_USE_FILES.has(file)) return true;
+  return (POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES).has(file);
+}
+function point_of_use_files(entry, cited) {
+  const reached = [...POINT_OF_USE_FILES].filter((file) => cited.has(file));
+  return [...reached, ...POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES];
+}
+var read_set_point_of_use = {
+  POINT_OF_USE_FILES,
+  POINT_OF_USE_BY_ENTRY,
+  is_point_of_use,
+  point_of_use_files
+};
+
+// scripts/document/entry-read-set.ts
+var { POINT_OF_USE_FILES: POINT_OF_USE_FILES2, POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2, is_point_of_use: is_point_of_use2, point_of_use_files: point_of_use_files2 } = read_set_point_of_use;
+var { cost_of: cost_of2, scoped_file_cost: scoped_file_cost2, total: total2 } = read_set_cost;
+var SKILL_DIRECTORY = path.join(".claude", "skills", "workflow-commands");
+var SKILL_FILE = "SKILL.md";
+var LANE_CHILD = "lane-child";
+var TABLE_SECTION = "1. Which file to read";
+var NOTHING2 = 0;
+var HEADING_JOINER = '" + "';
+var SUBSECTION_PREFIX = "### ";
+var TABLE_ROW = /^\|(?<entry>[^|]+)\|(?<files>[^|]+)\|\s*$/u;
+var MARKDOWN_NAME = /`(?<name>[\w.-]+\.md)`/gu;
+var ENTRY_KEYWORD = /`(?<keyword>[a-z]+)/u;
+var SECTION_REFERENCE = /`(?<file>[\w.-]+\.md)` *→ *"(?<heading>[^"]+)"/gu;
+var WHITESPACE_RUN = /\s+/gu;
+function document_path(root, name) {
+  const in_project = path.join(root, SKILL_DIRECTORY, name);
+  const in_package = path.join(PACKAGE_DIR, SKILL_DIRECTORY, name);
+  const project_manifest = path.join(root, "package.json");
+  if (root !== "" && existsSync(project_manifest) && existsSync(in_package)) return in_package;
+  return existsSync(in_project) ? in_project : in_package;
+}
+function read_document(root, name) {
+  return document_section.read_optional(document_path(root, name)) ?? "";
+}
+function unique(names) {
+  return [...new Set(names)];
+}
+function all_matches(text, pattern) {
+  const scanner = new RegExp(pattern.source, pattern.flags);
+  const found = [];
+  let match = scanner.exec(text);
+  while (match !== null) {
+    found.push(match);
+    match = scanner.exec(text);
+  }
+  return found;
+}
+function group_of(match, name) {
+  return match.groups?.[name] ?? "";
+}
+function names_in(text) {
+  return all_matches(text, MARKDOWN_NAME).map((match) => group_of(match, "name"));
+}
+function columns_of(line) {
+  const groups = TABLE_ROW.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  const { entry = "", files = "" } = groups;
+  return { entry, files };
+}
+function to_row(line) {
+  const columns = columns_of(line);
+  if (columns === void 0) return void 0;
+  const { keyword } = ENTRY_KEYWORD.exec(columns.entry)?.groups ?? {};
+  return keyword === void 0 ? void 0 : { keyword, files: names_in(columns.files) };
+}
+function push_row(rows, line) {
+  const row = to_row(line);
+  if (row !== void 0 && row.files.length > NOTHING2) rows.set(row.keyword, row.files);
+}
+function table_rows(root) {
+  const rows = /* @__PURE__ */ new Map();
+  const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION);
+  const lines = (found?.text ?? "").split("\n");
+  for (const line of lines) {
+    if (line.startsWith(SUBSECTION_PREFIX)) break;
+    push_row(rows, line);
+  }
+  return rows;
+}
+function files_for(root, entry) {
+  if (entry === LANE_CHILD) return [path.basename(lane_instructions.WORKFLOW_ENTRY)];
+  const declared = table_rows(root).get(entry) ?? [];
+  return unique([SKILL_FILE, ...declared]).filter((file) => !is_point_of_use2(entry, file));
+}
+function fold(text) {
+  return text.replaceAll(WHITESPACE_RUN, " ").trim();
+}
+function is_sibling_document(root, name) {
+  return document_section.read_optional(document_path(root, name)) !== void 0;
+}
+function is_counted(root, entry, reference, files) {
+  if (is_point_of_use2(entry, reference.file)) return false;
+  return !files.includes(reference.file) && is_sibling_document(root, reference.file);
+}
+function to_reference(match) {
+  return { file: group_of(match, "file"), heading: fold(group_of(match, "heading")) };
+}
+function references_from(root, entry, text, files) {
+  return all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match)).filter((reference) => is_counted(root, entry, reference, files));
+}
+function sort_key(reference) {
+  return `${reference.file} ${reference.heading}`;
+}
+function dedupe(references) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const reference of references) seen.set(sort_key(reference), reference);
+  return [...seen].map(([, reference]) => reference);
+}
+function sections_for(root, entry, files) {
+  const found = files.filter((file) => file !== SKILL_FILE).flatMap((file) => references_from(root, entry, read_document(root, file), files));
+  return dedupe(found).toSorted((left, right) => sort_key(left).localeCompare(sort_key(right)));
+}
+function read_set(root, entry) {
+  const files = files_for(root, entry);
+  return { entry, files, sections: sections_for(root, entry, files) };
+}
+function section_cost(root, reference) {
+  const found = document_section.section(read_document(root, reference.file), reference.heading);
+  return {
+    ...reference,
+    // **An unresolvable reference is charged at the whole file.** Reporting it at zero would let a
+    // broken pointer read as a saving, which is the one direction this measurement must not move.
+    cost: cost_of2(found?.text ?? read_document(root, reference.file)),
+    is_resolved: found !== void 0
+  };
+}
+function referenced_cost(root, sections) {
+  const files = unique(sections.map((reference) => reference.file));
+  return total2(files.map((file) => cost_of2(read_document(root, file))));
+}
+function headings_for(sections, file) {
+  return sections.filter((reference) => reference.file === file).map((one) => one.heading);
+}
+function scoped_cost(root, sections) {
+  const files = unique(sections.map((reference) => reference.file));
+  return total2(
+    files.map((file) => scoped_file_cost2(read_document(root, file), headings_for(sections, file)))
+  );
+}
+function file_costs(root, names) {
+  return names.map((file) => ({ file, cost: cost_of2(read_document(root, file)) }));
+}
+function point_of_use_cost(root, file, references) {
+  const markdown = read_document(root, file);
+  const headings = unique(references.filter((one) => one.file === file).map((one) => one.heading));
+  if (headings.length === NOTHING2) {
+    return { file, heading: "", cost: cost_of2(markdown), is_resolved: true };
+  }
+  return {
+    file,
+    heading: headings.join(HEADING_JOINER),
+    cost: scoped_file_cost2(markdown, headings),
+    is_resolved: headings.every(
+      (heading) => document_section.section(markdown, heading) !== void 0
+    )
+  };
+}
+function path_texts(root, entry, table_text) {
+  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
+  const rows = table_text.split("\n").filter((line) => line.startsWith("|") && line.includes(`\`${entry}\``));
+  return [...manifests.map((file) => read_document(root, file)), ...rows];
+}
+function point_of_use_references(root, entry, table_text) {
+  const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE);
+  const texts = [table_text, ...manifests.map((file) => read_document(root, file))];
+  return texts.flatMap(
+    (text) => all_matches(text, SECTION_REFERENCE).map((match) => to_reference(match))
+  );
+}
+function entry_table_text(root) {
+  return document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? "";
+}
+function point_of_use_costs(root, entry, also) {
+  const table_text = entry === LANE_CHILD ? "" : entry_table_text(root);
+  const references = point_of_use_references(root, entry, table_text);
+  const named = path_texts(root, entry, table_text).flatMap((text) => names_in(text));
+  const cited = /* @__PURE__ */ new Set([...also, ...named]);
+  return point_of_use_files2(entry, cited).map((file) => point_of_use_cost(root, file, references));
+}
+function costed(root, entry, also = /* @__PURE__ */ new Set()) {
+  const { files, sections } = read_set(root, entry);
+  const own_costs = file_costs(root, files);
+  const section_costs = sections.map((reference) => section_cost(root, reference));
+  const own = total2(own_costs.map((row) => row.cost));
+  return {
+    entry,
+    files: own_costs,
+    sections: section_costs,
+    point_of_use: point_of_use_costs(root, entry, also),
+    bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
+    whole: total2([own, referenced_cost(root, sections)]),
+    scoped: total2([own, scoped_cost(root, sections)])
+  };
+}
+function entries(root) {
+  return [...table_rows(root)].map(([keyword]) => keyword);
+}
+var entry_read_set = {
+  HARNESS_DEFAULT_CAP_CHARS: bash_output_cap_reader.HARNESS_DEFAULT_CAP_CHARS,
+  POINT_OF_USE_BY_ENTRY: POINT_OF_USE_BY_ENTRY2,
+  POINT_OF_USE_FILES: POINT_OF_USE_FILES2,
+  SECTION_REFERENCE,
+  SKILL_DIRECTORY,
+  SKILL_FILE,
+  TABLE_SECTION,
+  bash_output_cap: bash_output_cap_reader.bash_output_cap,
+  cost_of: cost_of2,
+  costed,
+  document_path,
+  entries,
+  read_set,
+  total: total2
+};
+
+export {
+  entry_read_set
+};

package/dist/commands/chunk-LS7P324N.js

@@ -0,0 +1,72 @@
+import {
+  BLOCKER,
+  PAGE,
+  blocker_node_schema,
+  git_gh_issue_graphql,
+  git_gh_issue_rest
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_transport
+} from "./chunk-LX2ENXHZ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-blocked-by-graphql.ts
+import { z } from "zod";
+var IDS_PER_QUERY = 100;
+var BLOCKED_BY_QUERY = `query($ids: [ID!]!) {
+	nodes(ids: $ids) { ... on Issue { id blockedBy(${PAGE}) { nodes { ${BLOCKER} } } } }
+}`;
+var issue_node_schema = z.object({
+  id: z.string(),
+  blockedBy: z.object({ nodes: z.array(blocker_node_schema) })
+});
+var nodes_schema = z.array(issue_node_schema.nullable());
+var response_schema = z.looseObject({ data: z.looseObject({ nodes: nodes_schema }) });
+function needs_read(row) {
+  if (row.node_id === void 0 || git_gh_issue_rest.is_pull_request(row)) return false;
+  return git_gh_issue_rest.total_blocked_by(row) !== 0;
+}
+function chunks_of(items) {
+  const chunks = [];
+  for (let start = 0; start < items.length; start += IDS_PER_QUERY) {
+    chunks.push(items.slice(start, start + IDS_PER_QUERY));
+  }
+  return chunks;
+}
+function to_blocked_by(row, node) {
+  const nodes = node.blockedBy.nodes.map(
+    (blocker) => git_gh_issue_graphql.to_blocking_issue(blocker)
+  );
+  return { nodes, totalCount: git_gh_issue_rest.total_blocked_by(row) ?? nodes.length };
+}
+async function query_nodes(ids) {
+  const json = await git_gh_transport.query({ query: BLOCKED_BY_QUERY, variables: { ids } });
+  if (json === void 0) return [];
+  return json_value.parse_with(json, response_schema)?.data.nodes ?? [];
+}
+function index_by_id(nodes) {
+  const resolved = nodes.filter((node) => node !== null);
+  return new Map(resolved.map((node) => [node.id, node]));
+}
+async function read_chunk(rows, answered) {
+  const by_id = index_by_id(await query_nodes(rows.map((row) => row.node_id)));
+  for (const row of rows) {
+    const node = by_id.get(row.node_id);
+    if (node !== void 0) answered.set(row, to_blocked_by(row, node));
+  }
+}
+async function read_answered(rows) {
+  const answered = /* @__PURE__ */ new Map();
+  const chunks = chunks_of(rows.filter((row) => needs_read(row)));
+  for (const chunk of chunks) {
+    await read_chunk(chunk, answered);
+  }
+  return answered;
+}
+var git_gh_blocked_by_graphql = { chunks_of, read_answered };
+
+export {
+  git_gh_blocked_by_graphql
+};

package/dist/commands/chunk-LU5EOGFQ.js

@@ -0,0 +1,50 @@
+import {
+  get_exit_code,
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/git-grep-hits.ts
+var GREP_LINE = /^(?<path>[^:]+):(?<line>\d+):(?<text>.*)$/u;
+var MAX_EXCERPT_LENGTH = 80;
+var ELLIPSIS = "\u2026";
+var GREP_NO_MATCH_EXIT = 1;
+function shorten(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= MAX_EXCERPT_LENGTH) return trimmed;
+  return `${trimmed.slice(0, MAX_EXCERPT_LENGTH)}${ELLIPSIS}`;
+}
+function to_hit(output_line) {
+  const groups = GREP_LINE.exec(output_line)?.groups;
+  if (groups === void 0) return void 0;
+  const { path, line, text } = groups;
+  return { path, line, excerpt: shorten(text) };
+}
+function parse(stdout) {
+  const hits = stdout.split("\n").map((line) => to_hit(line));
+  return hits.filter((hit) => hit !== void 0);
+}
+async function search(target, flags, pathspecs, root) {
+  const location = root === void 0 ? [] : ["-C", root];
+  const grep_arguments = [
+    ...location,
+    "grep",
+    "-n",
+    "-I",
+    "-F",
+    ...flags,
+    "-e",
+    target,
+    "--",
+    ...pathspecs
+  ];
+  try {
+    return { hits: parse(await git_spawn.read(grep_arguments)), has_failed: false };
+  } catch (error) {
+    return { hits: [], has_failed: get_exit_code(error) !== GREP_NO_MATCH_EXIT };
+  }
+}
+var git_grep_hits = { parse, search };
+
+export {
+  git_grep_hits
+};